if (-2 <= b && b <= 2) {
      switch ((int) b) {
        case 0:
          return (k == 0) ? 1 : 0;
        case 1:
          return 1;
        case (-1):
          return ((k & 1) == 0) ? 1 : -1;
        case 2:
          return (k < Long.SIZE) ? 1L << k : 0;
        case (-2):
          if (k < Long.SIZE) {
            return ((k & 1) == 0) ? 1L << k : -(1L << k);
          } else {

        assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
        assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);

        range1 = VersionRange.createFromVersionSpec("(,1.0], [1.1,)");
        range2 = VersionRange.createFromVersionSpec("1.2");
        mergedRange = range1.restrict(range2);
        assertEquals("1.2", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);

	n := argc + 1
	for argv_index(argv, n) != nil {
		n++
	}
	executablePath = gostringnocopy(argv_index(argv, n+1))

	// strip "executable_path=" prefix if available, it's added after OS X 10.11.
	const prefix = "executable_path="
	if len(executablePath) > len(prefix) && executablePath[:len(prefix)] == prefix {
		executablePath = executablePath[len(prefix):]
	}
}

func signalM(mp *m, sig int) {

    // CHECK-SAME: (tensor<*xi32>, tensor<*xf32>, tensor<i32>)
    %1:3 = func.call @WhileOp_body(%arg0, %arg1, %cst) : (tensor<*xi32>, tensor<*xf32>, tensor<i32>) -> (tensor<*xi32>, tensor<*xf32>, tensor<i32>)
    "tfl.yield"(%1#0, %1#1) : (tensor<*xi32>, tensor<*xf32>) -> ()
  }) : (tensor<i32>, tensor<1xf32>) -> (tensor<i32>, tensor<1xf32>) loc("WhileOp")
  // CHECK: (tensor<i32>, tensor<1xf32>, tensor<i32>) ->

    if (-2 <= b && b <= 2) {
      switch ((int) b) {
        case 0:
          return (k == 0) ? 1 : 0;
        case 1:
          return 1;
        case (-1):
          return ((k & 1) == 0) ? 1 : -1;
        case 2:
          return (k < Long.SIZE) ? 1L << k : 0;
        case (-2):
          if (k < Long.SIZE) {
            return ((k & 1) == 0) ? 1L << k : -(1L << k);
          } else {

    }

    private Map<String, Schema> loadSchemas() {
        // NOTE: it would be nice to load all schemas from the classpath, but 1.0, 1.1 and 1.2 are invalid
        def versions = ["1.3"]
        SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

        def result = versions.collectEntries { version ->

// CHECK:   cf.br ^bb1([[BODYRETS]]#0, [[BODYRETS]]#1 : tensor<*xf32>, tensor<*xf32>)
// CHECK: ^bb3([[EXITARG0:%.+]]: tensor<*xf32>, [[EXITARG1:%.+]]: tensor<*xf32>):

  func.return %1#0, %1#1 : tensor<*xf32>, tensor<*xf32>
// CHECK:   return [[EXITARG0]], [[EXITARG1]] : tensor<*xf32>, tensor<*xf32>
}


func.func private @testWhile0Cond() -> (tensor<i1>)
func.func private @testWhile0Body() -> ()

cmp stdout .hg-bookmarks

-- .hg-tags --
tip                               24:645b06ca536d
v2.0.0                            23:814fce58e83a
v2.0.6                            17:3d4b89a2d059
v1.1.0                            11:92c7eb888b4f
submod/v1.0.5                     10:f3f560a6065c
v1.0.3                             9:4e58084d459a
submod/v1.0.4                      9:4e58084d459a
v1.0.2                             8:3ccdce3897f9

//
// 01: package p
// 02:
// 03: var v, w, z int
// 04:
// 05: func small(x, y int) int {
// 06:   v++
// 07:   // comment
// 08:   if y == 0 {
// 09:     return x
// 10:   }
// 11:   return (x << 1) ^ (9 / y)
// 12: }
// 13:
// 14: func Medium(q, r int) int {
// 15:   s1 := small(q, r)
// 16:   z += s1
// 17:   s2 := small(r, q)
// 18:   w -= s2
// 19:   return w + z

        // CHECK: tf_device.return %[[A]], %[[C]]

        // CHECK: %[[B:.*]] = "tf.B"(%[[TPU0_OUTPUT]]#0)
        // CHECK: tf_executor.yield %[[B]], %[[TPU0_OUTPUT]]#1
      }
      tf_executor.fetch %1#0, %1#1 : tensor<?xi32>, tensor<?xi32>
    }
    func.return %0#0, %0#1 : tensor<?xi32>, tensor<?xi32>
  }
}

// -----

// Multiple device clusters with intertwined instructions in original block.