}
			val, err := IterToValue(elem.Iter)
			if err != nil {
				return nil, false, err
			}
			return jsonpathEval(p[1:], val)
		default:
			return nil, false, errKeyLookup
		}

	case p[0].Index != nil:
		idx := *p[0].Index

		arr, ok := v.([]any)
		if !ok {
			return nil, false, errIndexLookup
		}

		if idx >= len(arr) {
			return nil, false, nil
		}
		return jsonpathEval(p[1:], arr[idx])

			if !tt.wantIdx && len(idx) > 0 {
				t.Errorf("index returned above threshold")
			}
			if tt.wantIdx {
				if idx == nil {
					t.Errorf("no index returned")
				}
				var index s2.Index
				_, err = index.Load(s2.RestoreIndexHeaders(idx))
				if err != nil {
					t.Errorf("error loading index: %v", err)
				}
				t.Log("size:", len(idx))
				t.Log(string(index.JSON()))

    }

    private void establishChannel(int index) throws IOException {
        // Select interfaces for this channel
        NetworkInterfaceInfo localIf = selectLocalInterface(index);
        NetworkInterfaceInfo remoteIf = selectRemoteInterface(index);

        if (localIf == null || remoteIf == null) {
            log.warn("Cannot select interfaces for channel {}", index);
            return;
        }

          - --update-existing
        files: ^docs/en/docs/.*\.md$

      - id: generate-readme
        language: unsupported
        name: generate README.md from index.md
        entry: uv run ./scripts/docs.py generate-readme
        files: ^docs/en/docs/index\.md|docs/en/data/sponsors\.yml|scripts/docs\.py$
        pass_filenames: false

      - id: update-languages
        language: unsupported
        name: update languages

		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{}
}

        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())
						}
					}
				}
			}
		}

        }
    }

    /**
     * Asserts that the index is valid.
     *
     * @param argName
     *            The name of the argument that must not be {@code null}.
     * @param argValue
     *            The value of the index.
     * @param arraySize
     *            The length of the array the index refers to.
     * @throws ClIllegalArgumentException

	}

	errStr := ""
	var wg sync.WaitGroup
	for index := range globalNotificationSys.peerClients {
		if globalNotificationSys.peerClients[index] == nil {
			continue
		}
		go func(index int) {
			for i := 0; i < connectionsPerPeer; i++ {
				wg.Add(1)
				go func() {
					defer wg.Done()
					err := globalNotificationSys.peerClients[index].DevNull(ctx, r)
					if err != nil {

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

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

        children[index % nChildren] = kid;
    }

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