trace.Stop()
}

func pullRange(n int) intIter {
	next, stop := iter.Pull(func(yield func(v int) bool) {
		for i := range n {
			yield(i)
		}
	})
	return intIter{next: next, stop: stop}
}

type intIter struct {
	next func() (int, bool)
	stop func()

func.func @check_consecutive_unary_ops_outside_compiled(%arg0: tensor<?xi32>) {
  // CHECK: "tf_device.cluster"
  // CHECK-NEXT: "tf.Cast"
  // CHECK-SAME: _xla_outside_compilation = ""
  // CHECK-NEXT: "tf.Identity"
  // CHECK-SAME: _xla_outside_compilation = ""
  // CHECK-NEXT: "tf.B"
  "tf_device.cluster"() ({
    %1 = "tf.Cast"(%arg0) : (tensor<?xi32>) -> (tensor<?xi32>)

	var md *moduledata
	for next := &firstmoduledata; next != nil; next = next.next {
		if base >= next.types && base < next.etypes {
			md = next
			break
		}
	}
	if md == nil {
		reflectOffsLock()
		res := reflectOffs.m[int32(off)]
		reflectOffsUnlock()
		if res == nil {
			println("runtime: typeOff", hex(off), "base", hex(base), "not in ranges:")

			s.next()
		}
		// if we are at '\n', the position following the comment is afterwards
		next = s.offset
		if s.ch == '\n' {
			next++
		}
		goto exit
	}

	/*-style comment */
	s.next()
	for s.ch >= 0 {
		ch := s.ch
		if ch == '\r' {
			numCR++
		} else if ch == '\n' && nlOffset == 0 {
			nlOffset = s.offset
		}
		s.next()
		if ch == '*' && s.ch == '/' {
			s.next()

     // CHECK: "tf_device.parallel_execute"
     // CHECK-NEXT: "tf_device.launch"
     // CHECK-NEXT: "tf.B"
     // CHECK-NEXT: "tf.C"
     // CHECK-NEXT: "tf.D"
     // CHECK-NOT: _xla_outside_compilation
     // CHECK: "tf_device.cluster"
     // CHECK-NEXT: "tf.A"
     // CHECK-NEXT: "tf.E"
     // CHECK: device_assignment =  [], num_cores_per_replica = 1 : i64, topology =  ""

// RUN: tf-mlir-translate -mlir-to-graphdef %s -o - | FileCheck %s

func.func @main() {
^bb0:
  // CHECK:      key: "listvalue"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   list {
  // CHECK-NEXT:     s: " \n"
  // CHECK-NEXT:   }
  // CHECK:      key: "value"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   s: " 0\n\000\000"
  tf_executor.graph {

		codeInit()
		b.StartTimer()
	}

	// Trigger an error in Marshal with cyclic data.
	type Dummy struct {
		Name string
		Next *Dummy
	}
	dummy := Dummy{Name: "Dummy"}
	dummy.Next = &dummy

	b.RunParallel(func(pb *testing.PB) {
		enc := NewEncoder(io.Discard)
		for pb.Next() {
			if err := enc.Encode(&codeStruct); err != nil {
				b.Fatalf("Encode error: %v", err)
			}

# CHECK-NEXT:    %[[ARG1]] = f32[2]{0} parameter(1)
# CHECK-NEXT:    %[[ARG0]] = f32[2]{0} parameter(0)
# CHECK-NEXT:    ROOT %tuple.{{[0-9]+}} = (f32[2]{0}) tuple(f32[2]{0} %[[ARG0]])
# CHECK-NEXT:  }

# CHECK:       // InputMapping {0, 1}
# CHECK-NEXT:  // XlaInputShape f32[2]
# CHECK-NEXT:  // XlaInputShape f32[2]
# CHECK-NEXT:  // XlaOutputShape (f32[2])

import (
	"fmt"
	"reflect"
	"os"
)

func f(next func() bool) {
	for b := next(); b; b = next() {
		fmt.Printf("%v\n", b)
		os.Exit(0)
	}
}

func main() {
	next := reflect.MakeFunc(reflect.TypeOf((func() bool)(nil)), func(_ []reflect.Value) []reflect.Value {
		return []reflect.Value{reflect.ValueOf(true)}
	})
	reflect.ValueOf(f).Call([]reflect.Value{next})

    }
  }

// CHECK:       module {
// CHECK-NEXT:    func @main(%arg0: tensor<8x128xf32>, %arg1: tensor<f32>) -> tensor<11x131xf32> {
// CHECK-NEXT:      %0 = stablehlo.pad %arg0, %arg1, low = [1, 0], high = [2, 3], interior = [0, 0] : (tensor<8x128xf32>, tensor<f32>) -> tensor<11x131xf32>
// CHECK-NEXT:      return %0 : tensor<11x131xf32>
// CHECK-NEXT:    }