func (c *sigctxt) r7() uint64  { return (uint64)(c.regs().sc_x[7]) }
func (c *sigctxt) r8() uint64  { return (uint64)(c.regs().sc_x[8]) }
func (c *sigctxt) r9() uint64  { return (uint64)(c.regs().sc_x[9]) }
func (c *sigctxt) r10() uint64 { return (uint64)(c.regs().sc_x[10]) }
func (c *sigctxt) r11() uint64 { return (uint64)(c.regs().sc_x[11]) }
func (c *sigctxt) r12() uint64 { return (uint64)(c.regs().sc_x[12]) }

	tf_tid   *int32
	tf_stack uintptr
}

type sigcontext struct {
	__sc_unused int32
	sc_mask     int32
	sc_sp       uintptr
	sc_lr       uintptr
	sc_elr      uintptr
	sc_spsr     uintptr
	sc_x        [30]uintptr
	sc_cookie   int64
}

type siginfo struct {
	si_signo  int32
	si_code   int32
	si_errno  int32
	pad_cgo_0 [4]byte
	_data     [120]byte
}

type stackt struct {

func (c *sigctxt) a3() uint64  { return uint64(c.regs().sc_a[3]) }
func (c *sigctxt) a4() uint64  { return uint64(c.regs().sc_a[4]) }
func (c *sigctxt) a5() uint64  { return uint64(c.regs().sc_a[5]) }
func (c *sigctxt) a6() uint64  { return uint64(c.regs().sc_a[6]) }
func (c *sigctxt) a7() uint64  { return uint64(c.regs().sc_a[7]) }
func (c *sigctxt) s2() uint64  { return uint64(c.regs().sc_s[2]) }

type sigcontext struct {
	__sc_unused int32
	sc_mask     int32
	sc_ra       uintptr
	sc_sp       uintptr
	sc_gp       uintptr
	sc_tp       uintptr
	sc_t        [7]uintptr
	sc_s        [12]uintptr
	sc_a        [8]uintptr
	sc_sepc     uintptr
	sc_f        [32]uintptr
	sc_fcsr     uintptr
	sc_cookie   int64
}

type siginfo struct {
	si_signo  int32
	si_code   int32
	si_errno  int32

		t.Run(testcase.config, func(t *testing.T) {
			sctx := &serverCtxt{}
			err := mergeServerCtxtFromConfigFile(testcase.config, sctx)
			if testcase.expectedErr && err == nil {
				t.Error("expected failure, got success")
			}
			if !testcase.expectedErr && err != nil {
				t.Error("expected success, got failure", err)
			}
			if err == nil {
				if len(sctx.Layout.pools) != 2 {

	return errors.New("hey!")
}

type Server struct {
	FooServer *FooServer
	user      string
	ctx       context.Context
}

func New(sctx context.Context, u string) (*Server, error) {
	s := &Server{user: u, ctx: sctx}
	s.FooServer = (*FooServer)(s)
	return s, nil

      return failure();
    }

    // The input tensors x and y are 2-D or higher with shape:
    //       [..., r_x == 1, c_x] and [..., c_y, r_y].
    // The position of r_* and c_* are determined by the polarity of
    // the adj(X|Y) attribute, respectively.
    // So adjX == True indicates [..., c_x, r_x == 1].
    llvm::ArrayRef<int64_t> lhs_shape =
        mlir::cast<RankedTensorType>(bmm_op.getX().getType()).getShape();

>>; .issue29198.user <type -16>; .issue29198.ctx <type 10>; }>>>;
>;
type <type 8>;
func New (sctx <type 10>, u <type -16>) (? <type 43 *<type 5>>, ? <type -19>);
type <type 5>;

			out:  `0x0008\s00008\s\(.*\)\tMOVQ\t\$1,\sBX`,
		},
		{
			name: "16-byte alignment",
			code: "TEXT ·foo(SB),$0-0\nMOVQ $0, AX\nPCALIGN $16\nMOVQ $2, CX\nRET\n",
			out:  `0x0010\s00016\s\(.*\)\tMOVQ\t\$2,\sCX`,
		},
	}

	for _, test := range testCases {
		if err := os.WriteFile(tmpfile, []byte(test.code), 0644); err != nil {
			t.Fatal(err)
		}

  Output max = op.input(2);

  Output s_x = Shape(scope, x);
  Output s_min = Shape(scope, min);
  Output s_max = Shape(scope, max);

  Output min_mask = Less(scope, x, min);
  Output max_mask = Greater(scope, x, max);

  auto r_min = internal::BroadcastGradientArgs(scope, s_x, s_min);
  auto r_max = internal::BroadcastGradientArgs(scope, s_x, s_max);

  Output grad = grad_inputs[0];