Err    uint32
	Es     uint16
	Ds     uint16
	Rip    int64
	Cs     int64
	Rflags int64
	Rsp    int64
	Ss     int64
}

type FpReg struct {
	Env   [4]uint64
	Acc   [8][16]uint8
	Xacc  [16][16]uint8
	Spare [12]uint64
}

type FpExtendedPrecision struct{}

type PtraceIoDesc struct {
	Op   int32
	Offs uintptr
	Addr *byte
	Len  uint64
}

//
// and:
//
//	NewRootObjectFunc(), then acc(x) == x
//	NewRootObjectFunc().Index(), then acc([x]) == x
//	NewRootObjectFunc().Index().Child("foo"), then acc([{"foo": x}]) == x
//	NewRootObjectFunc().Index().Child("foo").Child("bar"), then acc([{"foo": {"bar":x}}]) == x
//	NewRootObjectFunc().Index().Child("foo").Child("bar").Index(), then acc([{"foo": {"bar":[x]}}]) == x

	z.Add(&x, &y)
	fmt.Printf("x = %.10g (%s, prec = %d, acc = %s)\n", &x, x.Text('p', 0), x.Prec(), x.Acc())
	fmt.Printf("y = %.10g (%s, prec = %d, acc = %s)\n", &y, y.Text('p', 0), y.Prec(), y.Acc())
	fmt.Printf("z = %.10g (%s, prec = %d, acc = %s)\n", &z, z.Text('p', 0), z.Prec(), z.Acc())
	// Output:
	// x = 1000 (0x.fap+10, prec = 64, acc = Exact)
	// y = 2.718281828 (0x.adf85458248cd8p+2, prec = 53, acc = Exact)

	}
	subPool.Put(sub)
}

func subjectStartsWithGatewayReplyPrefix(subj []byte) bool {
	return len(subj) > 8 && string(subj[:4]) == "foob"
}

func (c *client) gatewayInterest(acc, subj string) *SublistResult {
	ei, _ := c.gw.outsim.Load(acc)
	var r *SublistResult
	e := ei.(*outsie)
	r = e.sl.Match(subj)
	return r
}

func (s *Sublist) Match(subject string) *SublistResult {
	return nil

	t.Lock()
	defer t.Unlock()
	// budget accumulated since last access
	now := t.clock.Now()
	acc := now.Sub(t.last).Seconds() * t.refresh.Seconds()
	if acc < 0 {
		acc = 0
	}
	// update current budget and store the current time
	if t.budget = t.budget + time.Duration(acc*1e9); t.budget > t.maxBudget {
		t.budget = t.maxBudget
	}
	t.last = now
	result := t.budget
	t.budget = time.Duration(0)

    @def_function.function(
        input_signature=[tensor_spec.TensorSpec((), dtypes.float32)])
    def compute(self, value):
      acc, _ = while_loop.while_loop(
          cond=lambda acc, i: i > 0,
          body=lambda acc, i: (acc + i, i - 1),
          loop_vars=(constant_op.constant(0.0), value))
      return acc

  to_save = Module()
  saved_model.save(
      to_save, export_dir=os.path.join(base_dir, "SimpleWhileLoop"))

    }

    static Collection<String> pathTo(EdgeState edge, boolean includeLast) {
        List<List<EdgeState>> acc = Lists.newArrayListWithExpectedSize(1);
        pathTo(edge, new ArrayList<>(), acc, new HashSet<>());
        List<String> result = Lists.newArrayListWithCapacity(acc.size());
        for (List<EdgeState> path : acc) {
            EdgeState target = Iterators.getLast(path.iterator());
            StringBuilder sb = new StringBuilder();

        duplicateClasses.isEmpty()
    }

    private static def collectJars(TestFile file, Collection<File> acc = []) {
        if (file.name.endsWith('.jar')) {
            acc.add(file)
        }
        if (file.isDirectory()) {
            file.listFiles().each { f -> collectJars(f, acc) }
        }
        acc
    }

		// 		return true
		// 	}

		// 	return fn(r)
		// })
	}

	return FromIterator[R](IteratorFunc[R](it))
}

func Reduce[T, U any](s Stream[T], identity U, acc func(U, T) U) (r U) {
	r = identity
	s.Iterate(func(t T) bool {
		r = acc(r, t)
		return true
	})

	return r
}

type myIterator struct {
}

func (myIterator) Iterate(fn func(int) bool) {
}

func main() {

	{"$GOFILE", []string{"proc.go"}},
	{"$GOPACKAGE", []string{"sys"}},
	{"a $XXNOTDEFINEDXX b", []string{"a", "", "b"}},
	{"/$XXNOTDEFINED/", []string{"//"}},
	{"/$DOLLAR/", []string{"/$/"}},
	{"yacc -o $GOARCH/yacc_$GOFILE", []string{"go", "tool", "yacc", "-o", runtime.GOARCH + "/yacc_proc.go"}},
}

func TestGenerateCommandParse(t *testing.T) {
	dir := filepath.Join(testenv.GOROOT(t), "src", "sys")
	g := &Generator{