return x ^ y
		},
	}
	cop = [2]byte{'|', '^'}
)

func gentest(b *bufio.Writer, bits uint, unsigned, inverted bool) {
	fmt.Fprintf(b, "func init() {\n")
	defer fmt.Fprintf(b, "}\n")
	n := 0

	// Generate tests for left/right and right/left.
	for l := uint(0); l <= bits; l++ {
		for r := uint(0); r <= bits; r++ {
			for o, op := range cop {
				typ := fmt.Sprintf("int%d", bits)

  EXPECT_EQ(names3[4], "c");
}

TEST(ScopeTest, SingleUseScope) {
  Scope root = Scope::NewRootScope();
  auto cop_scopes = root.GetCompositeOpScopes("cop");
  // cop_scopes.last is a single use scope
  EXPECT_EQ(cop_scopes.last.GetUniqueNameForOp("foo"), "cop");
  cop_scopes.last.GetUniqueNameForOp("foo");
  // Error status should be set on cop_scopes.last
  EXPECT_FALSE(cop_scopes.last.ok());
}

      iter.hasNext();
      fail();
    } catch (IllegalStateException expected) {
    }
  }

  // Technically we should test other reentrant scenarios (4 combinations of
  // hasNext/next), but we'll cop out for now, knowing that
  // next() both start by invoking hasNext() anyway.

  /** Throws an undeclared checked exception. */
  private static void sneakyThrow(Throwable t) {

	cop := OpConst64
	switch v.Op {
	case OpAdd32, OpSub32:
		cop = OpConst32
	case OpAdd16, OpSub16:
		cop = OpConst16
	case OpAdd8, OpSub8:
		cop = OpConst8
	}
	switch v.Op {
	case OpAdd64, OpAdd32, OpAdd16, OpAdd8:
		if v.Args[0].Op == cop {
			return v.Args[1], v.Args[0].AuxInt
		}
		if v.Args[1].Op == cop {
			return v.Args[0], v.Args[1].AuxInt

	"cook_islands":                         "\U0001f1e8\U0001f1f0",
	"cookie":                               "\U0001f36a",
	"cool":                                 "\U0001f192",
	"cop":                                  "\U0001f46e",
	"copyright":                            "\u00a9\ufe0f",
	"corn":                                 "\U0001f33d",
	"costa_rica":                           "\U0001f1e8\U0001f1f7",

							break;
						default:
							p.cp = p.p;
							p.cr = p.r;
							break;
					}
				}
				p.np = p.cr == -1 ? p.rt.get_container() : p.cr;
				p.op = p.ot._get_parent(p.o);
				p.cop = p.o.index();
				if(p.op === -1) { p.op = p.ot ? p.ot.get_container() : this.get_container(); }
				if(!/^(before|after)$/.test(p.p) && p.op && p.np && p.op[0] === p.np[0] && p.o.index() < p.cp) { p.cp++; }