attr: {
    key: "Tcaptured"
    value: {
      list: {
        type: [DT_INT64]
      }
    }
  }
  attr: {
    key: "Tin"
    value: {
      list: {
        type: [DT_INT64]
      }
    }
  }
  attr: {
    key: "Tout"
    value: {
      list: {
        type: [DT_INT64]
      }
    }
  }
  attr: {
    key: "batch_timeout_micros"
    value: {

        string_val: "value"
      }
    }
  }
}
node {
  name: "Const_2"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT64
        tensor_shape {
        }
        int64_val: -1
      }
    }
  }
}
node {
  name: "result"
  op: "ParseExample"
  input: "serilaized"

          }
        }
      }
    }
  }
}
node {
  name: "Const0"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT64
        tensor_shape {
        }
        int64_val: -1
      }
    }
  }
  attr {
    key: "_output_shapes"
    value {
      list {

  OpDef op_def = reg->op_def;
  NodeDef def;
  TF_CHECK_OK(NodeDefBuilder("dummy", &op_def)
                  .Attr("type", DT_INT8)
                  .Attr("T", DT_INT64)
                  .Input(FakeInput(DT_INT64))
                  .Finalize(&def));
  shape_inference::InferenceContext c(0, def, op_def, {S({3, 4})}, {}, {}, {});
  std::vector<shape_inference::ShapeHandle> input_shapes;

                   .WithXlaCluster("cluster_0");

  Output input = ops::Placeholder(root.WithOpName("input"), DT_FLOAT);
  Output begin = ops::Placeholder(root.WithOpName("begin"), DT_INT64);
  Output size = ops::Placeholder(root.WithOpName("size"), DT_INT64);
  Output slice = ops::Slice(root.WithOpName("slice"), input, begin, size);

  std::unique_ptr<Graph> result;
  TF_ASSERT_OK(IncreaseDynamismForAutoJit(root, &result));

      {},
      // Nodes
      {
          {{"two"},
           "Const",
           {},
           {{"value", test::AsScalar<int32>(2)}, {"dtype", DT_INT64}}},
          {{"scale"},
           "Cast",
           {"two"},
           {{"SrcT", DT_INT64}, {"DstT", DT_FLOAT}}},
          {{"y"}, "Mul", {"x", "scale"}, {{"T", DT_FLOAT}}},
      });

  tensorflow::set_tf2_execution(true);
  FunctionDefLibrary flib;

    tf_executor.fetch %0#2 : !tf_executor.control
  }
  func.return
}

// CHECK-LABEL: func @testNextIterationMissingSourceDevice
func.func @testNextIterationMissingSourceDevice() {
  tf_executor.graph {
    // CHECK:      tf_executor.NextIteration.Source
    %0:3 = tf_executor.NextIteration.Source : tensor<i64> {T = "tfdtype$DT_INT64"}
    // CHECK:      "tf.Identity"({{.+}}) :

      }
    }
  }
}
node {
  name: "y"
  op: "Const"
  device: "/device:CPU:0"
  attr {
    key: "dtype"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT64
        tensor_shape {
          dim {
            size: 2
          }
          dim {
            size: 3
          }
        }

  return {slice_inputs};
}

// Casts `x` to a DT_INT64 if it isn't one already.
Output MakeInt64(const Scope& host_scope, absl::string_view name,
                 const Output& x) {
  return x.type() == DT_INT64
             ? x
             : ops::Cast(host_scope.WithOpName(name, "_s64"), x, DT_INT64);
}

// Returns `slice_inputs` with the index and size inputs cast to DT_INT64.

  inputs.emplace_back("min", 0, DT_FLOAT);
  inputs.emplace_back("max", 0, DT_FLOAT);
  inputs.emplace_back("histogram", 0, DT_INT64);
  inputs.emplace_back("min", 0, DT_FLOAT);
  inputs.emplace_back("max", 0, DT_FLOAT);
  inputs.emplace_back("histogram", 0, DT_INT64);

  const std::string dir = testing::TmpDir();
  const std::string output_file_path = io::JoinPath(dir, "statistics.pbtxt");