return failure();
  }

  // Compute slices for each batch in the LHS and RHS.
  std::vector<Value> sliced_lhs =
      sliceInput(input_lhs, bcast.x_batch_size(), loc, rewriter);
  std::vector<Value> sliced_rhs =
      sliceInput(input_rhs, bcast.y_batch_size(), loc, rewriter);

  // Compute (single batch) MatMul for each output batch.
  std::vector<Value> matmuls;
  matmuls.reserve(bcast.output_batch_size());

# CHECK: [[shape:%.*]] = "tf.Shape"([[ARG]])
# CHECK-NEXT: [[batch_size:%.*]] = "tf.StridedSlice"([[shape]],
# CHECK-NEXT: [[result:%.*]] = "tf.Pack"([[batch_size]],
# CHECK-NEXT: return [[result]] : tensor<2xi32>


def Test():

  x = tf.placeholder(dtype=tf.float32, shape=[None])
  batch_size = tf.shape(x)[0]
  r = tf.convert_to_tensor([batch_size, 1])

  tensor_info_x = meta_graph_pb2.TensorInfo(

        $output_shapes, $use_inter_op_parallelism, $preserve_cardinality,
        $force_synchronous, $map_dataset_metadata),
     $batch_size, $drop_remainder, $parallel_copy, $batch_output_types,
     $batch_output_shapes, $unused_batch_dataset_metadata),
  (TF_MapAndBatchDatasetOp $input_dataset, $other_arguments, $batch_size,
     (TF_ConstOp (GetI64ScalarElementsAttr<1>)), $drop_remainder, $f,

  //
  //  TARGET_PATH=tensorflow_models/official/legacy/image_classification       \
  //  bazel run -c opt --config=cuda ${TARGET_PATH}:resnet_imagenet_main       \
  //    -- --skip_eval --num_gpus=1 --dtype=fp16 --batch_size=192              \
  //    --train_steps=210 --enable_xla --enable_eager=true
  //
  // At CL 245846452
  TF_ASSERT_OK(RunAutoClusteringTestWithPbtxt("keras_imagenet_main"));
}

  %a2 = tfrt_fallback_async.const_dense_tensor dense<[[3, 3], [3, 3]]> : tensor<2x2xi32>
  %b = tfrt_fallback_async.const_dense_tensor dense<[[1, 1], [1, 1]]> : tensor<2x2xi32>

  // Two batch_size=2 batches get concatenated.
  %result_1 = tfrt_fallback_async.batch_function device("/device:CPU:0") @matmul_cpu (%a1, %b) {
      num_batch_threads = 1,
      max_batch_size = 4,
      allowed_batch_sizes = [4],

  attr {
    key: "preserve_cardinality"
    value {
      b: false
    }
  }
  attr {
    key: "use_inter_op_parallelism"
    value {
      b: true
    }
  }
}
node {
  name: "batch_size"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT64

  }
  tfr.return %res : !tfr.tensor
}

tfr.func @tf__my_map_and_batch_dataset(
    %input_dataset: !tfr.tensor,
    %other_arguments: !tfr.tensor_list,
    %batch_size: i64 {tfr.name="batch_size"},
    %num_parallel_calls: i64 {tfr.name="num_parallel_calls"},
    %drop_remainder: i1 {tfr.name="drop_remainder"},
    %f: !tfr.attr {tfr.name="func"},
    %output_types: !tfr.attr {tfr.name="output_types"},

# MNIST dataset parameters.
num_classes = 10  # total classes (0-9 digits).
num_features = 784  # data features (img shape: 28*28).
num_channels = 1

# Training parameters.
learning_rate = 0.001
display_step = 10
batch_size = 32

# Network parameters.
n_hidden_1 = 32  # 1st conv layer number of neurons.
n_hidden_2 = 64  # 2nd conv layer number of neurons.
n_hidden_3 = 64  # 1st fully connected layer of neurons.

     kernel_initializer=tf.variance_scaling_initializer(),
     data_format=data_format)

    # Use the image size without space-to-depth transform as the input of conv0.
    batch_size, h, w, channel = inputs.get_shape().as_list()
    conv0.build([
     batch_size, h * space_to_depth_block_size, w * space_to_depth_block_size,
     channel // (space_to_depth_block_size**2)
    ])

    kernel = conv0.weights[0]

	Enabled bool `json:"enabled"`
}

// Audit/Logger constants
const (
	Endpoint   = "endpoint"
	AuthToken  = "auth_token"
	ClientCert = "client_cert"
	ClientKey  = "client_key"
	BatchSize  = "batch_size"
	QueueSize  = "queue_size"
	QueueDir   = "queue_dir"
	Proxy      = "proxy"

	KafkaBrokers       = "brokers"
	KafkaTopic         = "topic"
	KafkaTLS           = "tls"
	KafkaTLSSkipVerify = "tls_skip_verify"