// RUN: tf-quant-opt %s -split-input-file -quant-insert-quantized-functions -quant-quantize-composite-functions | FileCheck --check-prefix=TF %s
// RUN: tf-quant-opt %s -split-input-file -quant-insert-quantized-functions -quant-quantize-composite-functions='target-opset=XLA' | FileCheck --check-prefix=XLA %s

// RUN: tac-opt-all-backends -tfl-raise-target-subgraphs %s -split-input-file | FileCheck %s
// RUN: tac-opt-all-backends -tfl-raise-target-subgraphs="skip-raise-cpu-ops=true" %s -split-input-file | FileCheck %s --check-prefixes=CHECK-SKIP-CPU
// RUN: tac-opt-all-backends -tfl-raise-target-subgraphs="ignore-inference-type=true" %s -split-input-file | FileCheck %s --check-prefixes=CHECK-IGNORE-INFERENCE-TYPE

module {
func.func @simpleWhile(%arg0: tensor<i32>) -> tensor<i32> {

// RUN: tf-opt %s -tf-device-decompose-resource-ops | FileCheck -check-prefixes=CHECK,ALWAYS-DECOMPOSE %s
// RUN: tf-opt %s -tf-device-decompose-resource-ops-in-cluster | FileCheck -check-prefixes=CHECK,CLUSTER-ONLY %s

// Tests different behavior of two passes if the op is outside cluster
// tf-device-decompose-resource-ops would always decompose the resource op.
// tf-device-decompose-resource-ops-in-cluster would not decompose ops outside

// Chain POSTROUTING (policy ACCEPT)
// target     prot opt source               destination
// KUBE-POSTROUTING  all  --  0.0.0.0/0            0.0.0.0/0            /* kubernetes postrouting rules *
// Maintain by kubelet network sync loop

// *nat
// :KUBE-POSTROUTING - [0:0]
// Chain KUBE-POSTROUTING (1 references)
// target     prot opt source               destination

			if len(q.Additionals) == 0 {
				t.Error("missing EDNS record")
			} else if opt, ok := q.Additionals[0].Body.(*dnsmessage.OPTResource); !ok {
				t.Errorf("additional record type %T, expected OPTResource", q.Additionals[0])
			} else if len(opt.Options) != 0 {
				t.Errorf("found %d Options, expected none", len(opt.Options))
			} else {
				got := int(q.Additionals[0].Header.Class)

// RUN: tf-opt -tfl-prepare-tf %s | FileCheck %s
// RUN: tf-opt %s -tf-layout-optimization=force-data-format=NHWC -tfl-prepare-tf  | FileCheck --check-prefix=LAYOUT --dump-input=always %s

module attributes {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 268 : i32}} {

		// HTTP1 only can have one persistent connection, and it will close all Idle connections
		// once the Kubelet heartbeat fails. However, since there are many edge cases that we can't
		// control, users can still opt-in to the previous behavior for closing the connections by
		// setting the environment variable DISABLE_HTTP2.
		if s := os.Getenv("DISABLE_HTTP2"); len(s) > 0 {

	}
	return Option(pow << maxLengthShift)
}

// isMaxLength reports whether an Option holds a maximum length.
func isMaxLength(opt Option) bool {
	return opt&maxLengthMask != 0
}

// maxLength returns the maximum length stored in an Option.
func maxLength(opt Option) int {
	return 1 << ((opt & maxLengthMask) >> maxLengthShift)
}

// Filter demangles a C++ or Rust symbol name,
// returning the human-readable C++ or Rust name.

func newContainerAllocateResponse(opts ...containerAllocateResponseBuilderOption) *pluginapi.ContainerAllocateResponse {
	b := &containerAllocateResponseBuilder{}
	for _, opt := range opts {
		opt(b)
	}

	return b.Build()
}

// Build uses the configured builder to create a ContainerAllocateResponse.
func (b *containerAllocateResponseBuilder) Build() *pluginapi.ContainerAllocateResponse {

				err = p.podSyncer.SyncTerminatedPod(ctx, update.Options.Pod, status)

			case update.WorkType == TerminatingPod:
				var gracePeriod *int64
				if opt := update.Options.KillPodOptions; opt != nil {
					gracePeriod = opt.PodTerminationGracePeriodSecondsOverride
				}
				podStatusFn := p.acknowledgeTerminating(podUID)

				// if we only have a running pod, terminate it directly