Clustered nodes: 2178
Unclustered nodes: 446
Number of clusters: 1

unclustered size 446
 AssignAddVariableOp 2
 Const 2
 DivNoNan 1
 Identity 1
 NoOp 1
 ReadVariableOp 2
 VarHandleOp 435
 _Retval 2
cluster 0 size 2178
 Add 17
 AddN 72
 ArgMax 1
 AssignAddVariableOp 1
 AssignSubVariableOp 106
 BiasAdd 1
 BiasAddGrad 1
 Cast 3
 Const 357
 Conv2D 53
 Conv2DBackpropFilter 53
 Conv2DBackpropInput 52

    }
  }
  experimental_debug_info {
  }
}
node {
  name: "main"
  op: "_Retval"
  input: "StatefulWhile:1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "main1"
  op: "_Retval"
  input: "StatelessWhile:1"
  attr {
    key: "T"
    value {

Unclustered nodes: 606
Number of clusters: 2

unclustered size 606
 AssignAddVariableOp 1
 Const 108
 DivNoNan 1
 Identity 2
 Merge 53
 PlaceholderWithDefault 1
 ReadVariableOp 2
 Switch 1
 _Arg 435
 _Retval 2
cluster 0 size 1910
 Add 16
 AddN 71
 ArgMax 1
 AssignAddVariableOp 1
 BiasAdd 1
 BiasAddGrad 1
 Cast 115
 Const 407
 Conv2D 53
 Conv2DBackpropFilter 53
 Conv2DBackpropInput 52
 Equal 1

        handle.sendrecv(rpc);
        if (rpc.retval != 0)
            throw new SmbException(rpc.retval, false);
    }

    public void close() throws IOException {
        MsrpcLsarClose rpc = new MsrpcLsarClose(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0)
            throw new SmbException(rpc.retval, false);
    }

    return false;
  }

  // _Arg nodes in a top-level function represent feeds and _Retval nodes in a
  // top-level function represent fetches.
  if (stack_depth == 1 &&
      (node.type_string() == "_Arg" || node.type_string() == "_Retval")) {
    absl::string_view uncompilable_reason = "top level _Arg or _Retval";
    MaybeMarkUncompilableNode(uncompilable_reason, *stack_trace,

  for (auto sharding_and_retval :
       llvm::zip(sharding_for_rets, terminator->getOpOperands())) {
    const auto& sharding = std::get<0>(sharding_and_retval);
    OpOperand& retval = std::get<1>(sharding_and_retval);
    if (failed(VerifySharding(retval.get().getType(), sharding)))
      return mlir::failure();
  }
  return mlir::success();
}

// Assign the logical device if an op has an attribute `TPU_REPLICATED_CORE:n`,

      StrEq("input_tensor:0"));

  // Match the `_Retval` node that corresponds to the return value of @main.
  const auto retval_node_itr =
      llvm::find_if(exported_model->graph_def().node(),
                    [](const NodeDef& node) { return node.op() == "_Retval"; });
  ASSERT_NE(retval_node_itr, exported_model->graph_def().node().end());

    TF_RETURN_IF_ERROR(status);
    graph->AddEdge(node, 0, main_node, i);
  }

  // Similarly with return values, create dummy _Retval nodes fed by `node`.
  for (int64_t i = 0, end = result_types.size(); i < end; ++i) {
    Node* node;
    string retval_name = absl::StrCat("_retval", i);
    Status status = NodeBuilder(retval_name, FunctionLibraryDefinition::kRetOp)
                        .Input(main_node, i)

// CHECK-NEXT:   name: "Add{{_.*_1}}"
// CHECK-NEXT:   op: "Add"
// CHECK-NEXT:   input: "input0"
// CHECK-NEXT:   input: "input1"
// CHECK:      node {
// CHECK-NEXT:   name: "Add"
// CHECK-NEXT:   op: "_Retval"
// CHECK-NEXT:   input: "Add{{_.*_1}}"
// CHECK-NEXT:   attr {
// CHECK-NEXT:     key: "T"
// CHECK-NEXT:     value {
// CHECK-NEXT:       type: DT_INT32
// CHECK-NEXT:     }
// CHECK-NEXT:   }

        public int retval;
        public rpc.policy_handle handle;

        public SamrCloseHandle(rpc.policy_handle handle) {
            this.handle = handle;
        }

        public void encode_in(NdrBuffer _dst) throws NdrException {
            handle.encode(_dst);
        }
        public void decode_out(NdrBuffer _src) throws NdrException {
            retval = (int)_src.dec_ndr_long();
        }