switch reflectValue.Kind() {
	case reflect.Map:
		results = [][]interface{}{make([]interface{}, len(fields))}
		for idx, field := range fields {
			mapValue := reflectValue.MapIndex(reflect.ValueOf(field.DBName))
			if mapValue.IsZero() {
				mapValue = reflectValue.MapIndex(reflect.ValueOf(field.Name))
			}
			results[0][idx] = mapValue.Interface()
		}

		dataResults[utils.ToStringKey(results[0]...)] = []reflect.Value{reflectValue}

      return new AbstractIterator<Entry<K, V>>() {
        private int index = -1;
        private final int maxIndex = keyToIndex().size();

        @Override
        protected @Nullable Entry<K, V> computeNext() {
          for (index++; index < maxIndex; index++) {
            V value = getValue(index);
            if (value != null) {
              return immutableEntry(getKey(index), value);

                                }
                                final String index = indexObj.get("_index");
                                if (index != null) {
                                    if (index.startsWith(".fess")) {
                                        indexObj.put("_index", index.substring(1));
                                    }
                                    if (index.endsWith("scheduled_job")) {

        return -1;
      }
      checkState(index > 0);
      int limit = min(index, size - len) + len;
      int minIndex = index;
      for (int i = index + 1; i < limit; i++) {
        if (compareElements(i, minIndex) < 0) {
          minIndex = i;
        }
      }
      return minIndex;
    }

    /** Returns the minimum child or {@code -1} if no child exists. */
    int findMinChild(int index) {

            line = f"{hashes} {title}"
        lines.append(line)
    return "\n".join(lines)


def generate_readme_content() -> str:
    en_index = en_docs_path / "docs" / "index.md"
    content = en_index.read_text("utf-8")
    content = remove_header_permalinks(content)  # remove permalinks from headers
    match_pre = re.search(r"</style>\n\n", content)

                    .map(line -> line//
                            .replace("\"_index\":\"fess_config.", "\"_index\":\"" + fessConfig.getIndexConfigIndex() + ".")//
                            .replace("\"_index\":\"fess_user.", "\"_index\":\"" + fessConfig.getIndexUserIndex() + ".")//
                            .replace("\"_index\":\"fess_log.", "\"_index\":\"" + fessConfig.getIndexLogIndex() + "."))
                    .reduce((prev, line) -> {

        try {
            zos.putNextEntry(entry);
            SearchEngineUtil.scroll(index, hit -> {
                final String data = "{\"index\":{\"_index\":\"" + index + "\",\"_id\":\"" + StringEscapeUtils.escapeJson(hit.getId())
                        + "\"}}\n" + hit.getSourceAsString() + "\n";
                try {

        }

        final Map<String, Object> firstLineMap = new HashMap<>();
        final Map<String, Object> firstLineInnerMap = new HashMap<>();
        firstLineInnerMap.put("_index", index);
        firstLineInnerMap.put("_type", type);
        firstLineInnerMap.put("_id", item.getId());
        firstLineMap.put("index", firstLineInnerMap);

					for _, key := range mapv.MapKeys() {
						k := strings.ToLower(key.String())
						if f, ok := association.Relationship.FieldSchema.FieldsByDBName[k]; ok {
							_ = f.Set(association.DB.Statement.Context, child, mapv.MapIndex(key).Interface())
						}
					}
					appendToFieldValues(child)
				}
			}

			switch rv.Kind() {
			case reflect.Map:
				processMap(rv)
			case reflect.Slice, reflect.Array: