// Check node "if" input and output edges.
  auto node_name_index = g->BuildNodeNameIndex();
  const Node *if_node = node_name_index.at("if");
  ASSERT_NE(if_node, nullptr);
  const Node *input_node;
  TF_CHECK_OK(if_node->input_node(1, &input_node));
  EXPECT_EQ(input_node->name(), "arg1");
  TF_CHECK_OK(if_node->input_node(2, &input_node));
  EXPECT_EQ(input_node->name(), "arg0");

    *uncompilable_reason = s.message();
    return false;
  }
  return true;
}

// Tests whether 'if_node' is compilable. Every operator in the then_branch and
// else_branch functions must be compilable for 'if_node' to be compilable.
bool RecursiveCompilabilityChecker::IsCompilableIf(
    const Node& if_node, FunctionLibraryRuntime* lib_runtime,
    std::vector<StackFrameView>* stack_trace,

  Node* if_node;
  TF_ASSERT_OK(
      NodeBuilder(kFunctionalIfNodeName, "If", &root.graph()->flib_def())
          .Input(predicate.node())
          .Input(if_inputs)
          .Attr("then_branch", uncompilable_fn1_attr)
          .Attr("else_branch", uncompilable_fn2_attr)
          .Attr("Tout", {DT_INT32})
          .Finalize(root.graph(), &if_node));

    // Check that the "If" node now has `send_if_pred_node` as attribute
    // _xla_token_input_nodes.
    Node *if_node = node_name_index["if"];
    EXPECT_NE(if_node, nullptr);
    std::vector<string> token_inputs;
    TF_CHECK_OK(
        GetNodeAttr(if_node->def(), "_xla_token_input_nodes", &token_inputs));
    EXPECT_THAT(token_inputs, ::testing::ElementsAre("send_oc_if_pred_if"));
  }
}

      std::vector<StackFrameView>* stack_trace,
      NameAttrList* encapsulating_function = nullptr,
      UncompilableNodesMap* uncompilable_nodes = nullptr) const;
  bool IsCompilableIf(const Node& if_node, FunctionLibraryRuntime* lib_runtime,
                      std::vector<StackFrameView>* stack_trace,
                      NameAttrList* encapsulating_function,

  if_builder.Input(if_inputs);
  NodeDef if_def;
  TF_RETURN_IF_ERROR(if_builder.Finalize(&if_def));
  TF_ASSIGN_OR_RETURN(Node * if_node, host_graph.AddNode(if_def));
  host_graph.AddEdge(recv_pred_node, 0, if_node, 0);
  host_graph.AddEdge(key_placeholder, 0, if_node, 1);

  // Convert `host_graph` to function.
  FunctionDef oc_host_graph_fdef;

     * 
     * @param tc
     *            context to use
     * @return {@link jcifs.netbios.NbtAddress#B_NODE},
     *         {@link jcifs.netbios.NbtAddress#P_NODE}, {@link jcifs.netbios.NbtAddress#M_NODE},
     *         {@link jcifs.netbios.NbtAddress#H_NODE}
     *
     * @throws UnknownHostException
     *             if the host cannot be resolved to find out.
     */

        return groupName;
    }

/** 
 * Checks the node type of this address.
 * @return {@link jcifs.smb1.netbios.NbtAddress#B_NODE},
 * {@link jcifs.smb1.netbios.NbtAddress#P_NODE}, {@link jcifs.smb1.netbios.NbtAddress#M_NODE},
 * {@link jcifs.smb1.netbios.NbtAddress#H_NODE}
 *
 * @throws UnknownHostException if the host cannot be resolved to find out.
 */ 

  C2="${3}"
  C2_KUBECONFIG="${4}"
  POD_TO_POD_AND_SERVICE_CONNECTIVITY="${5}"

  C1_NODE="${C1}-control-plane"
  C2_NODE="${C2}-control-plane"
  C1_DOCKER_IP=$(docker inspect -f "{{ .NetworkSettings.Networks.kind.IPAddress }}" "${C1_NODE}")
  C2_DOCKER_IP=$(docker inspect -f "{{ .NetworkSettings.Networks.kind.IPAddress }}" "${C2_NODE}")
  if [ "${POD_TO_POD_AND_SERVICE_CONNECTIVITY}" -eq 1 ]; then

func lfnodeValidate(node *lfnode) {
	if base, _, _ := findObject(uintptr(unsafe.Pointer(node)), 0, 0); base != 0 {
		throw("lfstack node allocated from the heap")
	}
	if lfstackUnpack(lfstackPack(node, ^uintptr(0))) != node {
		printlock()
		println("runtime: bad lfnode address", hex(uintptr(unsafe.Pointer(node))))
		throw("bad lfnode address")
	}
}

func lfstackPack(node *lfnode, cnt uintptr) uint64 {