}


    public static byte[] expandNFold ( byte[] data, int outlen ) {
        int lcm = lcm(outlen, data.length);
        byte[] buf = new byte[outlen];
        int carry = 0;
        for ( int i = lcm - 1; i >= 0; i-- ) {
            carry = carry_add(data, buf, carry, i);
        }

        if ( carry != 0 ) {
            for ( int i = outlen - 1; i >= 0; i-- ) {
                carry += ( buf[ i ] & 0xff );

		if err != nil {
			return nil, fmt.Errorf("error parsing fieldmap: %s", err)
		}
	}
	refstring := cfg.Meta.Annotations[file.ReferenceKey]
	var outref resource.Reference
	if refstring != "" {
		outref = &kube.Position{}
		err := json.Unmarshal([]byte(refstring), outref)
		if err != nil {
			return nil, fmt.Errorf("error parsing reference: %s", err)
		}
	}
	res.Origin = &kube.Origin{
		Type:            col,

            inner.value = "from outer: $outer.value"
        }
    }

    def "by-type input bindings are scoped to the outer scope"() {
        given:
        registry.registerInstance("values", "foo")
            .apply("values", ByTypeBindingInputRule)
            .registerInstance("element", new MutableValue(value: "outer"))
            .mutate {

	// be merged.
	case *ast.ForStmt:
		outer := d.breakTarget
		d.breakTarget = x
		d.findLabels(x.Body)
		d.breakTarget = outer

	case *ast.RangeStmt:
		outer := d.breakTarget
		d.breakTarget = x
		d.findLabels(x.Body)
		d.breakTarget = outer

	case *ast.SelectStmt:
		outer := d.breakTarget
		d.breakTarget = x
		d.findLabels(x.Body)
		d.breakTarget = outer

	case *ast.SwitchStmt:

fun test() {

    outer@while(true) {
        inner@while(false) {
            <expr>break@outer</expr>
        }
    }

        def outerContent = tmpDir.createDir("outer")
        def outer = tmpDir.file("outer.jar")
        outerContent.zipTo(outer)
        def originalHash = zipHasher.hash(snapshotContext(outer))

        when:
        def innerContent = tmpDir.createDir("inner")
        def inner = outerContent.file("inner.jar")
        innerContent.zipTo(inner)
        outerContent.zipTo(outer)

	"strings"
)

type Inner struct {
	Err int
}

func (i *Inner) NotExpectedInStackTrace() int {
	if i == nil {
		return 86
	}
	return 17 + i.Err
}

type Outer struct {
	Inner
}

func ExpectedInStackTrace() {
	var o *Outer
	println(o.NotExpectedInStackTrace())
}

func main() {
    defer func() {
        if r := recover(); r != nil {
        	stacktrace := string(debug.Stack())

  StringRef out_eq = equation.substr(idx_arrow + 2);

  int idx_comma = calc_eq.find(',');
  StringRef lhs_eq = calc_eq.substr(0, idx_comma);
  StringRef rhs_eq = calc_eq.substr(idx_comma + 1);

  if (absl::StrContains(rhs_eq, ",")) return false;

  int lhs_out_idx_start = out_eq.size();
  int lhs_out_idx_end = -1;
  int rhs_out_idx_start = out_eq.size();
  int rhs_out_idx_end = -1;

    @TestSubtype
    public Mall<Outdoor>.Shop<Electronics> ownerTypeIsSubtype(
        Outlet<Outdoor>.Shop<Electronics> shop) {
      return isSubtype(shop);
    }

    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public Mall<? extends Outdoor>.Shop<Electronics> ownerTypeIsSubtype_supertypeWithWildcard(
        Outlet<Outdoor>.Shop<Electronics> shop) {
      return isSubtype(shop);
    }

fun test() {

    outer@while(true) {
        inner@while(false) {
            break<expr>@outer</expr>
        }
    }