return gover{}
	}
	v.kind, x = x[:i], x[i:]
	if x == "" {
		return v
	}
	v.pre, x, ok = cutInt(x)
	if !ok || x != "" {
		return gover{}
	}

	return v
}

// cutInt scans the leading decimal number at the start of x to an integer
// and returns that value and the rest of the string.
func cutInt(x string) (n, rest string, ok bool) {
	i := 0
	for i < len(x) && '0' <= x[i] && x[i] <= '9' {
		i++

	}
	v.Kind, x = x[:i], x[i:]
	if x == "" {
		return v
	}
	v.Pre, x, ok = cutInt(x)
	if !ok || x != "" {
		return Version{}
	}

	return v
}

// cutInt scans the leading decimal number at the start of x to an integer
// and returns that value and the rest of the string.
func cutInt(x string) (n, rest string, ok bool) {
	i := 0
	for i < len(x) && '0' <= x[i] && x[i] <= '9' {
		i++

        hasher.putInt(array.length);
        for (double d : array) {
            hasher.putDouble(d);
        }
    }

    public static void putFloats(Hasher hasher, float[] array) {
        hasher.putInt(array.length);
        for (float f : array) {
            hasher.putInt(Float.floatToRawIntBits(f));
        }
    }

    public static void putLongs(Hasher hasher, long[] array) {
        hasher.putInt(array.length);

	pathExts.once.Do(initPathExts)
	name, _, ok := cutExt(de.Name(), pathExts.list)
	if !ok {
		return "", false
	}
	v := gover.FromToolchain(name)
	if v == "" {
		return "", false
	}
	return v, true
}

// cutExt looks for any of the known extensions at the end of file.
// If one is found, cutExt returns the file name with the extension trimmed,

        public void putHash(HashCode hashCode) {
            hasher.putInt(hashCode.length());
            hasher.putHash(hashCode);
        }

        @Override
        public void putInt(int value) {
            hasher.putInt(4);
            hasher.putInt(value);
        }

        @Override
        public void putLong(long value) {
            hasher.putInt(8);
            hasher.putLong(value);
        }

}

// TrimLeft returns a slice of the string s with all leading
// Unicode code points contained in cutset removed.
//
// To remove a prefix, use [TrimPrefix] instead.
func TrimLeft(s, cutset string) string {
	if s == "" || cutset == "" {
		return s
	}
	if len(cutset) == 1 && cutset[0] < utf8.RuneSelf {
		return trimLeftByte(s, cutset[0])
	}
	if as, ok := makeASCIISet(cutset); ok {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func putint(digits *string) {
	var i byte;
	i = (*digits)[7];  // compiles
	i = digits[7];  // ERROR "illegal|is not|invalid"
	_ = i;
}

func main() {
	s := "asdfasdfasdfasdf";
	putint(&s);
}

/*
bug022.go:8: illegal types for operand
	(*<string>*STRING) INDEXPTR (<int32>INT32)

        hasher.putInt(1)
        hasher.hash()

        when:
        hasher.hash()

        then:
        thrown(IllegalStateException)
    }

    def 'hashers can overlap'() {
        when:
        def hasher1 = Hashing.newHasher()
        hasher1.putInt(1)

        and:
        def hasher2 = Hashing.newHasher()
        hasher2.putInt(1)

            cacheHasher.putString(implementation.getName());
            cacheHasher.putInt(metadataResources.size());
            for (ResourcePattern ivyPattern : metadataResources) {
                cacheHasher.putString(ivyPattern.getPattern());
            }
            cacheHasher.putInt(artifactResources.size());
            for (ResourcePattern artifactPattern : artifactResources) {

  Hasher putBytes(ByteBuffer bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putShort(short s);

  @CanIgnoreReturnValue
  @Override
  Hasher putInt(int i);

  @CanIgnoreReturnValue
  @Override
  Hasher putLong(long l);

  /** Equivalent to {@code putInt(Float.floatToRawIntBits(f))}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putFloat(float f);