)

func main() {
	var b bool

	// constants
	b = (5 + 6i) == C1
	if !b {
		println("const bool 1", b)
		panic("fail")
	}

	b = (5 + 6i) != C1
	if b {
		println("const bool 2", b)
		panic("fail")
	}

	b = C1 == (5 + 6i)
	if !b {
		println("const bool 3", b)
		panic("fail")
	}

	b = C1 != (5 + 6i)
	if b {
		println("const bool 4", b)
		panic("fail")
	}

struct MlirCommonFlags {
  ConfigProto::Experimental::MlirBridgeRollout tf_mlir_enable_mlir_bridge;

  bool tf_mlir_enable_merge_control_flow_pass;
  bool tf_mlir_enable_convert_control_to_data_outputs_pass;
  bool tf_mlir_enable_composite_tpuexecute_side_effects;
  bool tf_mlir_enable_strict_clusters;
  bool tf_mlir_enable_tpu_variable_runtime_reformatting_pass;

  // ops of the same device, under a `tf_device.launch` op.
  bool form_clusters = false;
  // If `unfold_batch_matmul` is true, the tf.BatchMatMul is unfolded to a set
  // of tfl.fully_connected ops.
  bool unfold_batch_matmul = true;
  // Whether to outline WhileOp at the end of the pipeline.
  bool outline_tf_while = false;
  // Whether to do shape inference.
  bool shape_inference = true;
  // Whether to do TFLite runtime verification.

		}(G3("YBiKg"), G2(122.6))] = make(chan bool)
		ast0 = ast0
		i8_1 = (((G1(10)+i8_1)&i8_0+i8_0)&i8_0&i8_1 ^ i8_1) & i8_1
		am4 = am3
		i32_1 = int32(10) &^ i32_0
		m8[func(float64, G3) bool {
			return func(rune, int16) bool {
				return (G2(267.0)*G2(i2) == G2(i) || func(G2, G3) bool {
					return <-ch0
				}(G2(53.3), <-ch5)) && func(G2, G1) int32 {
					return int32(63)

	return d
}

func (d *poolDequeue) PushHead(val any) bool {
	return d.pushHead(val)
}

func (d *poolDequeue) PopHead() (any, bool) {
	return d.popHead()
}

func (d *poolDequeue) PopTail() (any, bool) {
	return d.popTail()
}

func NewPoolChain() PoolDequeue {
	return new(poolChain)
}

func (c *poolChain) PushHead(val any) bool {
	c.pushHead(val)
	return true
}

}

func (a Value) AsFloat64() (float64, bool) {
	if a.Kind() == KindFloat64 {
		return a.float(), true
	}
	return 0, false
}

func (a Value) AsBool() (bool, bool) {
	if a.Kind() == KindBool {
		return a.bool(), true
	}
	return false, false
}

func (a Value) AsDuration() (time.Duration, bool) {
	if a.Kind() == KindDuration {
		return a.duration(), true
	}
	return 0, false
}

	b = true && x < y          // permitted => result of && returns untyped bool
	b = x < y && x < y         // permitted => result of && returns untyped bool
	b = x < y || x < y         // permitted => result of || returns untyped bool
	var c bool = true && x < y // permitted => result of && is bool
	c = false || x < y         // permitted => result of || returns untyped bool
	_ = c

extern llvm::cl::opt<bool> allow_all_select_tf_ops;
extern llvm::cl::opt<bool> unfold_batchmatmul;
extern llvm::cl::opt<bool> unfold_large_splat_constant;
extern llvm::cl::opt<bool> guarantee_all_funcs_one_use;
extern llvm::cl::opt<bool> enable_dynamic_update_slice;
extern llvm::cl::opt<bool> preserve_assert_op;
extern llvm::cl::opt<bool> legalize_custom_tensor_list_ops;
extern llvm::cl::opt<bool> reduce_type_precision;

// Import saved model.

	EnableDynamicResourceAllocation              bool
	EnableVolumeCapacityPriority                 bool
	EnableNodeInclusionPolicyInPodTopologySpread bool
	EnableMatchLabelKeysInPodTopologySpread      bool
	EnablePodDisruptionConditions                bool
	EnableInPlacePodVerticalScaling              bool
	EnableSidecarContainers                      bool
	EnableSchedulingQueueHint                    bool

type Config struct {
	*telemetry.UploadConfig
	program         map[string]bool
	goos            map[string]bool
	goarch          map[string]bool
	goversion       map[string]bool
	pgversion       map[pgkey]bool
	pgcounter       map[pgkey]bool
	pgcounterprefix map[pgkey]bool
	pgstack         map[pgkey]bool
	rate            map[pgkey]float64
}

type pgkey struct {
	program, key string
}