Length uint32
		Locked uint32
	}
	NandOobinfo struct {
		Useecc   uint32
		Eccbytes uint32
		Oobfree  [8][2]uint32
		Eccpos   [32]uint32
	}
	NandOobfree struct {
		Offset uint32
		Length uint32
	}
	NandEcclayout struct {
		Eccbytes uint32
		Eccpos   [64]uint32
		Oobavail uint32
		Oobfree  [8]NandOobfree
	}
	MtdEccStats struct {
		Corrected uint32
		Failed    uint32

	// Thus, a backwards copy is performed here; that is, the exact bytes in
	// the source prior to the copy is placed in the destination.
	if srcPos < 0 {
		srcPos += len(dd.hist)
		dstPos += copy(dd.hist[dstPos:endPos], dd.hist[srcPos:])
		srcPos = 0
	}

	// Copy possibly overlapping section before destination position.
	//
	// This section can overlap if the copy length for this section is larger

                    ctx.decode(buffer, ncpos, dataLen);
                    contexts[ i ] = ctx;
                }
                ncpos += dataLen;
                if ( i != negotiateContextCount - 1 ) {
                    ncpos += pad8(ncpos);
                }
            }
            this.negotiateContexts = contexts;
            return Math.max(bufferIndex, ncpos) - start;
        }

func (s *Scanner) next() rune {
	ch, width := rune(s.srcBuf[s.srcPos]), 1

	if ch >= utf8.RuneSelf {
		// uncommon case: not ASCII or not enough bytes
		for s.srcPos+utf8.UTFMax > s.srcEnd && !utf8.FullRune(s.srcBuf[s.srcPos:s.srcEnd]) {
			// not enough bytes: read some more, but first
			// save away token text if any
			if s.tokPos >= 0 {
				s.tokBuf.Write(s.srcBuf[s.tokPos:s.srcPos])
				s.tokPos = 0
				// s.tokEnd is set by Scan()

     */
    public void find(char c) {
        int cpos = pos;
        while (cpos < input.length()) {
            if (input.charAt(cpos) == c) {
                break;
            }
            cpos++;
        }
        pos = cpos;
    }

    /**

	// Check that a hash match allows PGO inlining.
	const srcPos = "example.com/pgo/inline/inline_hot.go:81:19"
	const hashMatch = "pgohash triggered " + srcPos + " (inline)"
	pgoDebugRE := regexp.MustCompile(`hot-budget check allows inlining for call .* at ` + strings.ReplaceAll(srcPos, ".", "\\."))
	hash := "v1" // 1 matches srcPos, v for verbose (print source location)
	gcflag := gcflag0 + ",pgohash=" + hash

		return false
	}
	return prev.(*ImportSpec).Comment == nil
}

type posSpan struct {
	Start token.Pos
	End   token.Pos
}

type cgPos struct {
	left bool // true if comment is to the left of the spec, false otherwise.
	cg   *CommentGroup
}

func sortSpecs(fset *token.FileSet, f *File, specs []Spec) []Spec {

func NewClosureFunc(fpos, cpos src.XPos, why Op, typ *types.Type, outerfn *Func, pkg *Package) *Func {
	fn := NewFunc(fpos, fpos, closureName(outerfn, cpos, why), typ)
	fn.SetIsHiddenClosure(outerfn != nil)
	if outerfn != nil {
		fn.SetDupok(outerfn.Dupok()) // if the outer function is dupok, so is the closure
	}

	clo := &ClosureExpr{Func: fn}
	clo.op = OCLOSURE
	clo.pos = cpos
	clo.SetType(typ)
	clo.SetTypecheck(1)

    byte[] targetCopyArray = new byte[numBytes];

    int srcPos = Math.max(0, addressBytes.length - numBytes);
    int copyLength = addressBytes.length - srcPos;
    int destPos = numBytes - copyLength;

    // Check the extra bytes in the BigInteger are all zero.
    for (int i = 0; i < srcPos; i++) {
      if (addressBytes[i] != 0x00) {
        throw formatIllegalArgumentException(

    byte[] targetCopyArray = new byte[numBytes];

    int srcPos = Math.max(0, addressBytes.length - numBytes);
    int copyLength = addressBytes.length - srcPos;
    int destPos = numBytes - copyLength;

    // Check the extra bytes in the BigInteger are all zero.
    for (int i = 0; i < srcPos; i++) {
      if (addressBytes[i] != 0x00) {
        throw formatIllegalArgumentException(