DATA ·IEEEConst+1008(SB)/8,$0x000000018dc1d708
DATA ·IEEEConst+1016(SB)/8,$0x00000001e4ece95a

	/* x^195648 mod p(x), x^195584 mod p(x) */
DATA ·IEEEConst+1024(SB)/8,$0x000000002d4620a4
DATA ·IEEEConst+1032(SB)/8,$0x000000001a3ee918

	/* x^194624 mod p(x), x^194560 mod p(x) */
DATA ·IEEEConst+1040(SB)/8,$0x0000000058fd1740
DATA ·IEEEConst+1048(SB)/8,$0x000000007c652fb8

	/* x^193600 mod p(x), x^193536 mod p(x) */

	VPERM2I128 $0x02, AA2, BB2, AA0; VPERM2I128 $0x02, CC2, DD2, BB0; VPERM2I128 $0x13, AA2, BB2, CC0; VPERM2I128 $0x13, CC2, DD2, DD0
	VPXOR      (8*32)(inp), AA0, AA0; VPXOR (9*32)(inp), BB0, BB0; VPXOR (10*32)(inp), CC0, CC0; VPXOR (11*32)(inp), DD0, DD0
	VMOVDQU    AA0, (8*32)(oup); VMOVDQU BB0, (9*32)(oup); VMOVDQU CC0, (10*32)(oup); VMOVDQU DD0, (11*32)(oup)

func stack1024() { var buf [1024]byte; use(buf[:]); C.callGoStackCheck() }
func stack1028() { var buf [1028]byte; use(buf[:]); C.callGoStackCheck() }
func stack1032() { var buf [1032]byte; use(buf[:]); C.callGoStackCheck() }
func stack1036() { var buf [1036]byte; use(buf[:]); C.callGoStackCheck() }
func stack1040() { var buf [1040]byte; use(buf[:]); C.callGoStackCheck() }

	SYS_TEMPNAM                         = 0x31F // 799
	SYS_ACOSH                           = 0x320 // 800
	SYS_ASINH                           = 0x321 // 801
	SYS_ATANH                           = 0x322 // 802
	SYS_CBRT                            = 0x323 // 803
	SYS_EXPM1                           = 0x324 // 804
	SYS_ILOGB                           = 0x325 // 805
	SYS_LOGB                            = 0x326 // 806

	R_RISCV_TLS_DTPMOD64  R_RISCV = 7  /* ID of module containing symbol */
	R_RISCV_TLS_DTPREL32  R_RISCV = 8  /* 32 bit relative offset in TLS block */
	R_RISCV_TLS_DTPREL64  R_RISCV = 9  /* Relative offset in TLS block */
	R_RISCV_TLS_TPREL32   R_RISCV = 10 /* 32 bit relative offset in static TLS block */
	R_RISCV_TLS_TPREL64   R_RISCV = 11 /* Relative offset in static TLS block */

  %cst = "tf.Const"() { value = dense<[10, 3, 2]> : tensor<3xi32> } : () -> tensor<3xi32>
  %1 = "tf.ScatterNd"(%arg0, %arg1, %cst) : (tensor<5x1xi32>, tensor<5x3x2xf32>, tensor<3xi32>) -> tensor<10x3x2xf32>
  func.return %1 : tensor<10x3x2xf32>

// CHECK-LABEL:scatterNdVectorIndices
// CHECK: %[[CST:.*]] = arith.constant dense<[10, 3, 2]> : tensor<3xi32>

			t.Fatalf("queue.Len() = %v, want %v", got, want)
		}
	}
}

func bumpResourceVersion(obj metav1.Object) {
	ver, _ := strconv.ParseInt(obj.GetResourceVersion(), 10, 32)
	obj.SetResourceVersion(strconv.FormatInt(ver+1, 10))
}

// getQueuedKeys returns a sorted list of keys in the queue.
// It can be used to quickly check that multiple keys are in there.

	obj, isObj := object.(metav1.Object)
	if !isObj {
		return
	}
	if version := obj.GetResourceVersion(); version == "" {
		obj.SetResourceVersion("1")
	} else if intValue, err := strconv.ParseInt(version, 10, 32); err == nil {
		obj.SetResourceVersion(strconv.FormatInt(intValue+1, 10))
	}
}
func TestParallelScale(t *testing.T) {
	for _, tc := range []struct {
		desc                        string

	799:  {region: 0x29, script: 0x3, flags: 0x1},
	800:  {region: 0xcc, script: 0x5b, flags: 0x0},
	801:  {region: 0x166, script: 0x5b, flags: 0x0},
	802:  {region: 0x166, script: 0x5b, flags: 0x0},
	803:  {region: 0x166, script: 0x5b, flags: 0x0},
	804:  {region: 0x9a, script: 0x22, flags: 0x0},
	805:  {region: 0x52, script: 0x5b, flags: 0x0},
	807:  {region: 0x166, script: 0x5b, flags: 0x0},

					t.Errorf("Unexpected removal of the Job's finalizer")
				}
			}
		})
	}
}

func bumpResourceVersion(obj metav1.Object) {
	ver, _ := strconv.ParseInt(obj.GetResourceVersion(), 10, 32)
	obj.SetResourceVersion(strconv.FormatInt(ver+1, 10))
}

func TestJobApiBackoffReset(t *testing.T) {
	t.Cleanup(setDurationDuringTest(&DefaultJobApiBackOff, fastJobApiBackoff))