value {
      b: true
    }
  }
}
node {
  name: "batch_size"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT64
        tensor_shape {
        }
        int64_val: 5
      }
    }
  }
}
node {
  name: "drop_remainder"
  op: "Const"
  attr {

"tfdtype$DT_FLOAT"], dense_shapes = [#tf_type.shape<>, #tf_type.shape<>], device = "", num_sparse = 2 : i64, ragged_split_types = [], ragged_value_types = [], resultSegmentSizes = array<i32: 2, 2, 2, 2, 0, 0>, sparse_types = ["tfdtype$DT_STRING", "tfdtype$DT_INT64"]} : (tensor<32x!tf_type.string>, tensor<0x!tf_type.string>, tensor<2x!tf_type.string>, tensor<2x!tf_type.string>, tensor<0x!tf_type.string>, tensor<0xf32>, tensor<0xf32>) -> (tensor<?x2xi64>, tensor<?x2xi64>, tensor<?x!tf_type.string>, tensor<?xi64>,...

node {
  name: "x"
  op: "VarHandleOp"
  device: "/CPU:0"
  attr {
    key: "container"
    value {
      s: "a"
    }
  }
  attr {
    key: "dtype"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "shape"
    value {
      shape {
      }
    }
  }
  attr {
    key: "shared_name"
    value {
      s: "x"
    }
  }
}
node {

      type: DT_INT32
    }
  }
  attr {
    key: "index"
    value {
      i: 3
    }
  }
}
node {
  name: "args_4"
  op: "_Arg"
  attr {
    key: "T"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "index"
    value {
      i: 4
    }
  }
}
node {
  name: "IteratorGetNext"
  op: "IteratorGetNext"
  input: "args_0"
  attr {
    key: "output_shapes"

        }
        output_arg {
          name: "sparse_indices"
          type: DT_INT64
          number_attr: "Nsparse"
        }
        output_arg {
          name: "sparse_values"
          type_list_attr: "sparse_types"
        }
        output_arg {
          name: "sparse_shapes"
          type: DT_INT64
          number_attr: "Nsparse"
        }
        output_arg {

    case DT_INT16:
      *type = builder.getIntegerType(16);
      return absl::OkStatus();
    case DT_INT32:
      *type = builder.getIntegerType(32);
      return absl::OkStatus();
    case DT_INT64:
      *type = builder.getIntegerType(64);
      return absl::OkStatus();
    case DT_UINT8:
      *type = builder.getIntegerType(8, /*isSigned=*/false);
      return absl::OkStatus();
    case DT_UINT16:

// CHECK-NEXT:   value {
// CHECK-NEXT:     i: 0
// CHECK-NEXT:   }
// CHECK-NEXT: }
// CHECK-NEXT: attr {
// CHECK-NEXT:   key: "Tdense"
// CHECK-NEXT:   value {
// CHECK-NEXT:     list {
// CHECK-NEXT:       type: DT_INT64
// CHECK-NEXT:     }
// CHECK-NEXT:   }
// CHECK-NEXT: }
// CHECK-NEXT: attr {
// CHECK:        key: "dense_shapes"
// CHECK-NEXT:   value {
// CHECK-NEXT:     list {
// CHECK-NEXT:       shape {

    case tflite::TensorType_INT32:
      return tensorflow::DT_INT32;
    case tflite::TensorType_UINT32:
      return tensorflow::DT_UINT32;
    case tflite::TensorType_INT64:
      return tensorflow::DT_INT64;
    case tflite::TensorType_STRING:
      return tensorflow::DT_STRING;
    case tflite::TensorType_UINT8:
      return tensorflow::DT_UINT8;
    case tflite::TensorType_UINT16:
      return tensorflow::DT_UINT16;

  attr {
    key: "ragged_value_types"
    value {
      list {
      }
    }
  }
  attr {
    key: "sparse_types"
    value {
      list {
        type: DT_STRING
        type: DT_INT64
      }
    }
  }
}
versions {
  producer: 175

REGISTER_OP("TestComplexTFOp")
    .Input("lhs: T")
    .Input("rhs: Tlen")
    .Output("output: N * T")
    .Attr("N: int >= 1")
    .Attr("T: numbertype")
    .Attr("Tlen: {int32, int64} = DT_INT64");

REGISTER_OP("TestNumAttrsOp")
    .Attr("x1: int = -10")
    .Attr("y1: int = 1")
    .Attr("x2: float = 0.0")
    .Attr("y2: float = -3.0");

REGISTER_OP("TestNonNumAttrsOp")
    .Attr("z: shape")