batch_sizes: Sequence[int],
      target_opset: quant_opts_pb2.OpSet,
  ):
    lhs_batch_size, rhs_batch_size = batch_sizes
    input_shape = (*lhs_batch_size, 1, 1024)
    filter_shape = (*rhs_batch_size, 1024, 3)
    static_input_shape = [dim if dim is not None else 2 for dim in input_shape]
    model = self._create_matmul_model(
        input_shape,
        filter_shape,
        self._input_saved_model_path,

DATA ·IEEEConst+3896(SB)/8,$0x000000017e221efc

	/* x^11328 mod p(x), x^11264 mod p(x) */
DATA ·IEEEConst+3904(SB)/8,$0x00000000b1dba570
DATA ·IEEEConst+3912(SB)/8,$0x0000000167457c38

	/* x^10304 mod p(x), x^10240 mod p(x) */
DATA ·IEEEConst+3920(SB)/8,$0x00000001f6397b76
DATA ·IEEEConst+3928(SB)/8,$0x00000000bdf081c4

	/* x^9280 mod p(x), x^9216 mod p(x) */
DATA ·IEEEConst+3936(SB)/8,$0x0000000156335214

	nodeFsAvailableBytes := uint64(1024)
	nodeFsCapacityBytes := uint64(1024 * 2)
	imageFsInodesFree := uint64(1024)
	imageFsInodes := uint64(1024 * 1024)
	nodeFsInodesFree := uint64(1024)
	nodeFsInodes := uint64(1024 * 1024)
	containerFsAvailableBytes := uint64(1024 * 1024 * 2)
	containerFsCapacityBytes := uint64(1024 * 1024 * 8)
	containerFsInodesFree := uint64(1024 * 2)
	containerFsInodes := uint64(1024 * 2)

				},
			},
			machineState: state.NUMANodeMap{
				0: &state.NUMANodeState{
					MemoryMap: map[v1.ResourceName]*state.MemoryTable{
						v1.ResourceMemory: {
							Allocatable:    10240 * mb,
							Free:           10240 * mb,
							Reserved:       0,
							SystemReserved: 512 * mb,
							TotalMemSize:   10 * gb,
						},
						hugepages1Gi: {
							Allocatable:    10 * gb,

protected static final char[] VERSION; protected static final char[] NCODING; protected static final char[] TANDALONE; protected static final char[] YES; protected static final char[] NO; protected static final int LOOKUP_MAX = 1024; protected static final char LOOKUP_MAX_CHAR = 1024; protected static boolean[] lookupNameStartChar; protected static boolean[] lookupNameChar; protected void resetStringCache(); protected String newString(char[], int, int); protected String newStringIntern(char[], int, int);...

	addNotImplatedReaction(kubeClient)

	machineInfo := &cadvisorapi.MachineInfo{
		MachineID:      "123",
		SystemUUID:     "abc",
		BootID:         "1b3",
		NumCores:       2,
		MemoryCapacity: 1024,
	}
	kubelet.setCachedMachineInfo(machineInfo)

	done := make(chan struct{})
	go func() {
		kubelet.registerWithAPIServer()
		done <- struct{}{}
	}()
	select {

					return fmt.Errorf("unexpected load balancer. expected: %v, got: %v", cluster.Cluster_RING_HASH, c.LbPolicy)
				}
				if c.GetRingHashLbConfig().GetMinimumRingSize().Value != 1024 {
					return fmt.Errorf("unexpected minimum ring size. expected: %v, got: %v", 1024, c.GetRingHashLbConfig().GetMinimumRingSize().Value)
				}
				return nil
			},
		},
		{
			"consistent hash settings with deprecated minring size",

// Use initial buffer size in flatbuffer builder to be same as the initial size
// used by the TOCO export. (It does not explain rationale for this choice.)
constexpr size_t kInitialBufferSize = 10240;

// Flatbuffer fields to be padded to 16 bytes aligned.
constexpr size_t kFbAlignment = 16;

// Set `isSigned` to false if the `type` is an 8-bit unsigned integer type.

port: 443 protocol: TCP targetPort: 443 annotations: {} loadBalancerIP: "" loadBalancerSourceRa: [] externalTrafficPolic: "" externalIPs: [] ipFamilyPolicy: "" ipFamilies: [] resources: requests: cpu: 100m memory: 128Mi limits: cpu: 2000m memory: 1024Mi autoscaling: enabled: true minReplicas: 1 maxReplicas: 5 targetCPUUtilization: 80 targetMemoryUtilizat: {} autoscaleBehavior: {} # Pod environment variables env: {} # Labels to apply to all resources labels: {} # Annotations to apply to all resources...

		// We set hi to &size, but there are things above
		// it. The 1024 is supposed to compensate this,
		// but is somewhat arbitrary.
		size := gp.stack.hi
		if size == 0 {
			size = 16384 * sys.StackGuardMultiplier
		}
		gp.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))
		gp.stack.lo = gp.stack.hi - size + 1024
	}
	// Initialize stack guard so that we can start calling regular
	// Go code.