final SearchEngineClient client = new SearchEngineClient() {
            @Override
            public boolean update(final String index, final String id, final String field, final Object value) {
                resultMap.put("index", index);
                resultMap.put("id", id);
                resultMap.put("field", field);
                resultMap.put("value", value.toString());
                return true;
            }
        };

        return asJson(new ApiResult.ApiPluginResponse().plugins(list).status(ApiResult.Status.OK).result());
    }

    // PUT /api/admin/plugin
    @Execute
    public JsonResponse<ApiResult> put$index(final InstallBody body) {
        validateApi(body, messages -> {});
        final Artifact artifact = ComponentUtil.getPluginHelper().getArtifact(body.name, body.version);
        if (artifact == null) {

        firstLineInnerMap.put("_index", index);
        firstLineInnerMap.put("_type", type);
        firstLineInnerMap.put("_id", item.getId());
        firstLineMap.put("index", firstLineInnerMap);

        final Map<String, Object> secondLine = new HashMap<>();

        secondLine.put("text", item.getText());

        // reading

        final int i = ((inData[inIndex] & 0xff) << 16) + ((inData[inIndex + 1] & 0xff) << 8) + (inData[inIndex + 2] & 0xff);
        outData[outIndex] = ENCODE_TABLE[i >> 18];
        outData[outIndex + 1] = ENCODE_TABLE[i >> 12 & 0x3f];
        outData[outIndex + 2] = ENCODE_TABLE[i >> 6 & 0x3f];
        outData[outIndex + 3] = ENCODE_TABLE[i & 0x3f];
    }

    auto rhs_index = rhs_map.find(lhs[i]);
    auto out_index = out_map.find(lhs[i]);
    if (rhs_index == rhs_map.end() && out_index == out_map.end()) {
      dnums.lhs.emplace_back(i);
    } else if (rhs_index == rhs_map.end()) {
      dnums.lhs_out.emplace_back(i, out_index->second);
    } else if (out_index == out_map.end()) {
      dnums.lhs_rhs.emplace_back(i, rhs_index->second);
    } else {

	Punjabi              Tag = Tag{language: paIndex, locale: paIndex}
	Polish               Tag = Tag{language: plIndex, locale: plIndex}
	Portuguese           Tag = Tag{language: ptIndex, locale: ptIndex}
	BrazilianPortuguese  Tag = Tag{language: ptBRIndex, locale: ptBRIndex}
	EuropeanPortuguese   Tag = Tag{language: ptPTIndex, locale: ptPTIndex}
	Romanian             Tag = Tag{language: roIndex, locale: roIndex}

	ptMOIndex         ID = 578
	ptMZIndex         ID = 579
	ptPTIndex         ID = 580
	ptSTIndex         ID = 581
	ptTLIndex         ID = 582
	quIndex           ID = 583
	quBOIndex         ID = 584
	quECIndex         ID = 585
	quPEIndex         ID = 586
	rmIndex           ID = 587
	rmCHIndex         ID = 588
	rnIndex           ID = 589
	rnBIIndex         ID = 590
	roIndex           ID = 591
	roMDIndex         ID = 592

func (r *Request) PathValue(name string) string {
	if i := r.patIndex(name); i >= 0 {
		return r.matches[i]
	}
	return r.otherValues[name]
}

// SetPathValue sets name to value, so that subsequent calls to r.PathValue(name)
// return value.
func (r *Request) SetPathValue(name, value string) {
	if i := r.patIndex(name); i >= 0 {
		r.matches[i] = value
	} else {
		if r.otherValues == nil {

	{name: "GetCallerPC"},                         // for getcallerpc intrinsic
	{name: "GetCallerSP", argLength: 1},           // for getcallersp intrinsic. arg0=mem.

	// Indexing operations
	{name: "PtrIndex", argLength: 2},             // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type
	{name: "OffPtr", argLength: 1, aux: "Int64"}, // arg0 + auxint (arg0 and result are pointers)

(OffPtr p [0]) && v.Type.Compare(p.Type) == types.CMPeq => p

// indexing operations
// Note: bounds check has already been done
(PtrIndex <t> ptr idx) && config.PtrSize == 4 && is32Bit(t.Elem().Size()) => (AddPtr ptr (Mul32 <typ.Int> idx (Const32 <typ.Int> [int32(t.Elem().Size())])))
(PtrIndex <t> ptr idx) && config.PtrSize == 8 => (AddPtr ptr (Mul64 <typ.Int> idx (Const64 <typ.Int> [t.Elem().Size()])))

// struct operations