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 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();

			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];

//   * size(batching_dimensions) <= 3 (TFLite support restriction)
//   * size(contracting_dimensions) = 1
//   * Input tensors are per-tensor uniform quantized (i8->f32)
//     tensors (full integer) with shape [..., r_x, c_x] or [..., c_x, r_x].
//   * The filter tensor is a per-tensor uniform quantized (i8->f32) tensor
//     (constant or activation) with shape [..., r_y, c_y] or [..., c_y, r_y].

	// Use WithoutCancel instead of a new context.TODO() to propagate trace context
	// Call the container runtime's SyncPod callback
	sctx := context.WithoutCancel(ctx)
	result := kl.containerRuntime.SyncPod(sctx, pod, podStatus, pullSecrets, kl.backOff)
	kl.reasonCache.Update(pod.UID, result)
	if err := result.Error(); err != nil {
		// Do not return error if the only failures were pods in backoff