return new String(c);
    }

    /**
     * Converts a byte array to a hexadecimal string representation.
     *
     * @param src the source byte array to convert
     * @param srcIndex the starting index in the source array
     * @param size the number of bytes to convert from the source array
     * @return a hexadecimal string representation of the byte array
     */

				switch result.Kind() {
				case reflect.Struct:
					reflectResults = reflect.Append(reflectResults, result.Addr())
				case reflect.Slice, reflect.Array:
					for i := 0; i < result.Len(); i++ {
						if elem := result.Index(i); elem.Kind() == reflect.Ptr {
							reflectResults = reflect.Append(reflectResults, elem)
						} else {
							reflectResults = reflect.Append(reflectResults, elem.Addr())
						}
					}
				}
			}
		}

		if rv.Len() == 0 {
			builder.AddVar(builder, nil)
		} else {
			for i := 0; i < rv.Len(); i++ {
				if i > 0 {
					builder.WriteByte(',')
				}
				builder.AddVar(builder, rv.Index(i).Interface())
			}
		}
	default:
		builder.AddVar(builder, value)
	}
}

// IN Whether a value is within a set of values
type IN struct {
	Column interface{}
	Values []interface{}
}

    // ------------------------------------------------------------------------
    public void addChild(int index, MetadataTreeNode kid) {
        if (kid == null) {
            return;
        }

        if (children == null) {
            children = new MetadataTreeNode[nChildren];
        }

        children[index % nChildren] = kid;
    }

    // ------------------------------------------------------------------

            if (this.array != null) {
                _dst = _dst.deferred;
                final int _arrays = this.count;
                _dst.enc_ndr_long(_arrays);
                final int _arrayi = _dst.index;
                _dst.advance(4 * _arrays);

                _dst = _dst.derive(_arrayi);
                for (int _i = 0; _i < _arrays; _i++) {
                    this.array[_i].encode(_dst);
                }

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.web.util.LaRequestUtil;
import org.opensearch.index.query.BoolQueryBuilder;
import org.opensearch.index.query.DisMaxQueryBuilder;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;
import org.opensearch.search.sort.SortBuilder;
import org.opensearch.search.sort.SortBuilders;

	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	rd := msgp.NewEndlessReader(buf.Bytes(), b)

        this.rdmaCapable = false;
    }

    /**
     * Get the interface index
     *
     * @return interface index
     */
    public int getInterfaceIndex() {
        return interfaceIndex;
    }

    /**
     * Set the interface index
     *
     * @param interfaceIndex interface index
     */
    public void setInterfaceIndex(int interfaceIndex) {

        "term_vector": "with_positions_offsets"
      },
      "content_minhash": {
        "type": "keyword",
        "index": false
      },
      "content_minhash_bits": {
        "type": "keyword",
        "index": false
      },
      "content_length": {
        "type": "long"
      },
      "created": {
        "type": "date",

    sequenceOf("$path$CLASS_FILE_EXTENSION", "${path}Kt$CLASS_FILE_EXTENSION")


private
fun nestedClassNameFor(path: String) = path.run {
    lastIndexOf('/').takeIf { it > 0 }?.let { index ->
        substring(0, index) + '$' + substring(index + 1)
    }
}


private
fun normaliseFileSeparators(path: String): String =