func.func private @branch0(tensor<2xf32>) -> (tensor<2xf32>, tensor<2xf32>)
func.func private @branch1(tensor<2xf32>) -> tensor<2xf32>

func.func @testCaseMismatchedNumResults(%arg0: tensor<i32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  // expected-error @+1 {{'tf.Case' op branch #0 results (size = 2) should have the same number of values as results (size = 1)}}

	op_BCR     uint32 = 0x0700 // FORMAT_RR         BRANCH ON CONDITION
	op_BCT     uint32 = 0x4600 // FORMAT_RX1        BRANCH ON COUNT (32)
	op_BCTG    uint32 = 0xE346 // FORMAT_RXY1       BRANCH ON COUNT (64)
	op_BCTGR   uint32 = 0xB946 // FORMAT_RRE        BRANCH ON COUNT (64)
	op_BCTR    uint32 = 0x0600 // FORMAT_RR         BRANCH ON COUNT (32)
	op_BPP     uint32 = 0xC700 // FORMAT_SMI        BRANCH PREDICTION PRELOAD

  // `send_pred_node` has been generated.
  g->AddControlEdge(send_pred_node, n);

  // Build host side graph for the "If" node.
  // If then/else branch does not have outside compilation, we won't build host
  // graph for the branch. But here we need a host graph for both branches, so
  // we need to create a no-op host graph.
  if (!then_branch_has_outside_compilation) {
    std::unique_ptr<Graph> then_branch_host_graph(new Graph(fld));

  for (const auto& branch : llvm::enumerate(branches)) {
    auto branch_func = symbol_table.lookupNearestSymbolFrom<func::FuncOp>(
        op, mlir::cast<SymbolRefAttr>(branch.value()));
    if (!branch_func)
      return op->emitOpError()
             << "expects " << branch_name(branch.index()) << " ("
             << branch.value() << ") to point to a defined function";

					invertible := false

					if bo&0x14 == 0x14 {
						// A conditional branch that is unconditionally taken. This cannot be inverted.
					} else if bo&0x10 == 0x10 {
						// A branch based on the value of CTR. Invert the CTR comparison against zero bit.
						bo ^= 0x2
						invertible = true
					} else if bo&0x04 == 0x04 {
						// A branch based on CR bit. Invert the BI comparison bit.
						bo ^= 0x8
						invertible = true

      regions.push_back(RegionSuccessor());  // branch back to parent, no args
    }
  } else if (!point.isParent() && point == (*this)->getRegion(1)) {
    // 'body' branches back to 'cond'.
    regions.push_back(
        RegionSuccessor(&getCond(), getCond().front().getArguments()));
  } else if (point.isParent()) {
    // The parent branches to 'cond'. It is also considered to branch to `body`

    // CHECK: %[[CASE:.*]] = "tf.Case"(%[[ARG_0]], %[[ARG_1]])
    %0 = "tf.Case"(%arg0, %arg1) {branches = [@branch_0, @branch_1], is_stateless = false} : (tensor<i32>, tensor<!tf_type.resource<tensor<1x2x3xf32>>>) -> tensor<1x2x3xf32>
    // CHECK:           return %[[CASE]] : tensor<1x2x3xf32>
    func.return %0 : tensor<1x2x3xf32>
  }
  // CHECK-LABEL: func @branch_0

        max_iterations);
  } else if (auto case_op = dyn_cast<TF::CaseOp>(op)) {
    SmallVector<func::FuncOp, 4> branches;
    case_op.get_branch_functions(branches);
    return PropagateShapeToFunctions(module, case_op.getInput().getTypes(),
                                     branches, max_iterations);
  } else if (auto while_op = dyn_cast<TF::WhileOp>(op)) {

		}
		v >>= uint(shift)
		t = int64(1) << uint(flen-1)
		if v < -t || v >= t {
			c.ctxt.Diag("branch too far %#x vs %#x [%p]\n%v\n%v", v, t, c.blitrl, p, q)
			panic("branch too far")
		}
	}

	return v & ((t << 1) - 1)
}

/*
 * pc-relative branches
 */
func (c *ctxt7) opbra(p *obj.Prog, a obj.As) uint32 {
	switch a {
	case ABEQ:
		return OPBcc(0x0)

    output_graphdef = output_loader.get_meta_graph_def_from_tags(tags).graph_def
    self.assertTrue(self._contains_quantized_function_call(output_graphdef))

    # Tests that the false branch contains a quantized function call whereas the
    # true branch doesn't.
    def _is_quantized_function_call_node(
        node_def: node_def_pb2.NodeDef,
    ) -> bool:
      return node_def.op == 'PartitionedCall' and node_def.attr[