}
  }
  attr {
    key: "container"
    value {
      s: ""
    }
  }
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "shape"
    value {
      shape {
        dim {
          size: 117
        }
        dim {
          size: 224
        }
        dim {
          size: 224
        }
        dim {
          size: 3
        }

    }
  }
  attr {
    key: "_handle_dtypes"
    value {
      list {
        type: DT_FLOAT
      }
    }
  }
  attr {
    key: "_handle_shapes"
    value {
      list {
        shape {
          dim {
            size: 1001
          }
        }
      }
    }
  }
  attr {
    key: "index"
    value {
      i: 268
    }
  }
}
node {

                              .TypeConstraint("T", TYPES),                     \
                          ShapeOp<int64_t>);                                   \
  REGISTER_KERNEL_BUILDER(Name("ShapeN")                                       \
                              .Device(DEVICE)                                  \
                              .HostMemory("output")                            \

 FusedBatchNormGrad 53
 Identity 2
 MatMul 3
 MaxPool 1
 MaxPoolGrad 1
 Mean 1
 Mul 164
 Pad 1
 ReadVariableOp 646
 Relu 49
 ReluGrad 49
 Reshape 2
 ResourceApplyKerasMomentum 161
 ShapeN 50
 Softmax 1
 SparseSoftmaxCrossEntropyWithLogits 1
 Square 55
 Squeeze 1
 Sub 106
 Sum 57
 Tile 1

  // CHECK-DAG: %[[SHAPE1:.*]] = "tf.Const"() <{value = dense<[1, 32, 32, 16]> : tensor<4xi64>}>
  // CHECK: %[[SHAPE2:.*]] = "tf.Shape"(%arg2) : (tensor<*xf32>) -> tensor<?xi64>
  %0:3 = "tf.ShapeN"(%arg0, %arg1, %arg2) : (tensor<f32>, tensor<1x32x32x16xf32>, tensor<*xf32>) -> (tensor<0xi64>, tensor<4xi64>, tensor<?xi64>)

  // CHECK: return %[[SHAPE0]], %[[SHAPE1]], %[[SHAPE2]]

    "QuantizeAndDequantize",
    "QuantizeV2",
    "Rank",
    "Reshape",
    "ResourceStridedSliceAssign",
    "ReverseSequence",
    "ReverseV2",
    "ScatterNdNonAliasingAdd",
    "Shape",
    "ShapeN",
    "Size",
    "Slice",
    "Snapshot",
    "SpaceToBatch",
    "SpaceToBatchND",
    "SpaceToDepth",
    "Split",
    "SplitV",
    "Squeeze",
    "StopGradient",

 Const 11
 Equal 1
 ExpandDims 1
 ReverseSequence 1
 Shape 1
 StridedSlice 1
 Transpose 3
cluster 6 size 11
 Cast 1
 Const 5
 GatherV2 1
 Shape 1
 StridedSlice 1
 Transpose 1
 ZerosLike 1
cluster 7 size 33
 All 2
 Cast 1
 Const 17
 Equal 2
 ExpandDims 2
 GatherV2 1
 Identity 1
 ReverseSequence 1
 Shape 2
 StridedSlice 2
 Transpose 2
cluster 8 size 11

    inputs.push_back(op.input(i));
  }

  auto shapes = ShapeN(scope, inputs);
  const auto unique_name = scope.GetUniqueNameForOp("ConcatOffset");
  auto builder =
      ::tensorflow::NodeBuilder(unique_name, "ConcatOffset")
          .Input(::tensorflow::ops::AsNodeOut(scope, op.input(dim_index)))
          .Input(::tensorflow::ops::AsNodeOutList(scope, shapes.output));
  scope.UpdateBuilder(&builder);

  func.return
}

// -----

func.func @testConcatOffest(%concat_dim: tensor<i32>, %shape0: tensor<3xi32>, %shape1: tensor<3xi32>) {
  // expected-error @+1 {{'tf.ConcatOffset' op requires operand and result 1 to have compatible shapes}}

  //
  // For example,
  //
  //   %shape  = tf.Shape(%arg)                   // %arg: tensor<?x2x3x1xf32>
  //   %height = tf.StridedSlice(%shape, 1, 2, 1)
  //
  // In this case %height can be replaced with a constant 2.
  //
  // Or,
  //
  //   %shape  = tf.Shape(%arg)                   // %arg: tensor<?x2x3x1xf32>
  //   %spatial_shape = tf.StridedSlice(%shape, 1, 3, 1)
  //