MOVV	ptr+0(FP), R1
	MOVBU	val+8(FP), R2
	// Align ptr down to 4 bytes so we can use 32-bit load/store.
	MOVV	$~3, R3
	AND	R1, R3
	// Compute val shift.
#ifdef GOARCH_mips64
	// Big endian.  ptr = ptr ^ 3
	XOR	$3, R1
#endif
	// R4 = ((ptr & 3) * 8)
	AND	$3, R1, R4
	SLLV	$3, R4
	// Shift val for aligned ptr. R2 = val << R4
	SLLV	R4, R2

	SYNC
	LL	(R3), R4
	OR	R2, R4
	SC	R4, (R3)

            "pdName": "pdNameValue",
            "fsType": "fsTypeValue",
            "partition": 3,
            "readOnly": true
          },
          "awsElasticBlockStore": {
            "volumeID": "volumeIDValue",
            "fsType": "fsTypeValue",
            "partition": 3,
            "readOnly": true
          },
          "gitRepo": {
            "repository": "repositoryValue",

						},
					},
				},
			},
			pod: buildPod().uid("a").indexFailureCount("3").status(v1.PodStatus{
				Phase: v1.PodFailed,
				Conditions: []v1.PodCondition{
					{
						Type:   v1.DisruptionTarget,
						Status: v1.ConditionTrue,
					},
				},
			}).index("3").trackingFinalizer().Pod,
			wantNewIndexFailureCount:        3,
			wantNewIndexIgnoredFailureCount: 1,
		},
	}
	for name, tc := range cases {

              "pdName": "pdNameValue",
              "fsType": "fsTypeValue",
              "partition": 3,
              "readOnly": true
            },
            "awsElasticBlockStore": {
              "volumeID": "volumeIDValue",
              "fsType": "fsTypeValue",
              "partition": 3,
              "readOnly": true
            },
            "gitRepo": {

// CHECK: %3 = "tfl.dequantize"(%2) : (tensor<1x6x6x16x!quant.uniform<u8:f32, 3.906250e-03>>) -> tensor<1x6x6x16xf32>
// CHECK: return %3 : tensor<1x6x6x16xf32>
}

// CHECK-LABEL: NotRescaleLogistic
func.func @NotRescaleLogistic(%arg0: tensor<1x6x6x16x!quant.uniform<u8:f32, 7.812500e-03:128>>) -> tensor<1x6x6x16x!quant.uniform<u8:f32, 3.906250e-03>> {

        then: 1 * processor.started({ it.id == 2 && it.name == 'Gradle test' && it.className == null }, { it.parentId == 1 })
        then: 1 * processor.started({ it.id == 3 && it.name == 'ok' && it.className == ATestNGClass.name }, { it.parentId == 2 })
        then: 1 * processor.completed(3, { it.resultType == ResultType.SUCCESS })
        then: 1 * processor.completed(2, { it.resultType == null })
        then: 1 * processor.completed(1, { it.resultType == null })

// void	Or8(byte volatile*, byte);
TEXT ·Or8(SB),NOSPLIT,$0-5
	MOVW	ptr+0(FP), R1
	MOVBU	val+4(FP), R2
	MOVW	$~3, R3	// Align ptr down to 4 bytes so we can use 32-bit load/store.
	AND	R1, R3
#ifdef GOARCH_mips
	// Big endian.  ptr = ptr ^ 3
	XOR	$3, R1
#endif
	AND	$3, R1, R4	// R4 = ((ptr & 3) * 8)
	SLL	$3, R4
	SLL	R4, R2, R2	// Shift val for aligned ptr. R2 = val << R4
	SYNC
try_or8:
	LL	(R3), R4	// R4 = *R3

      periodSeconds: 4
      successThreshold: 5
      tcpSocket:
        host: hostValue
        port: portValue
      terminationGracePeriodSeconds: 7
      timeoutSeconds: 3
    name: nameValue
    ports:
    - containerPort: 3
      hostIP: hostIPValue
      hostPort: 2
      name: nameValue
      protocol: protocolValue
    readinessProbe:
      exec:
        command:
        - commandValue

              "mode": 3
            }
          ],
          "defaultMode": 3,
          "optional": true
        },
        "nfs": {
          "server": "serverValue",
          "path": "pathValue",
          "readOnly": true
        },
        "iscsi": {
          "targetPortal": "targetPortalValue",
          "iqn": "iqnValue",
          "lun": 3,
          "iscsiInterface": "iscsiInterfaceValue",

    %cst = "tf.Const"() {value = dense<3.000000e-01> : tensor<4x3x5x2xf32>} : () -> tensor<4x3x5x2xf32>
    %0 = "tf.XlaCallModule"(%arg0, %cst) {
      Sout = [#tf_type.shape<4x3x6x2>], _entry_function = @composite_dot_general_fn,
      _original_entry_function = "composite_dot_general_fn",
      _quantization_method = "weight_only_ptq {input_quantized_types {key: 1, value {dimension_specs {dimension: 3}}}}",