(TF_LookupTableFindOp:$src (TF_HashTableOp $container, $shared_name,
    $use_node_name_sharing, $key_dtype, $value_dtype), $keys, $default_value),
  (TF_LookupTableFindV2Op:$dest1 (TF_HashTableV2Op:$dest2 $container, $shared_name,
    $use_node_name_sharing, $key_dtype, $value_dtype), $keys, $default_value),
  [], [(CopyAttrs $src, $dest1), (CopyAttrs $src, $dest2)]>;

    "'int'} attr : { name: 'w_scale' type: 'float'} attr : { name: 'x_scale' "
    "type: 'float'} attr : { name: 'y_scale' type: 'float'} attr { name: "
    "'detections_per_class' type: 'int' default_value { i : 100 }} attr { "
    "name: 'use_regular_nms' type: 'bool' default_value { b : false }}";

constexpr mlir::StringRef kUnidirectionalSequenceLstmOp =
    "name: 'UnidirectionalSequenceLstm' input_arg: {name: 'Input' type: "

      ASSERT_EQ(2, op.attr_size());
      ASSERT_EQ("int", op.attr(0).type());
      ASSERT_EQ(2, op.attr(0).minimum());
      ASSERT_EQ("string", op.attr(1).type());
      ASSERT_EQ("my string", op.attr(1).default_value().s());
      found = true;
    }
  }
  ASSERT_TRUE(found);
  TF_DeleteStatus(status);
  TF_DeleteBuffer(op_list_buffer);
}

#define C_CTX(x) reinterpret_cast<TF_ShapeInferenceContext*>(x)

def LegalizeSparseToDense : Pat<
  (TF_SparseToDenseOp $sparse_indices, $output_shape, $sparse_values,
    $default_value, $validate_indices),
  (TFL_SparseToDenseOp $sparse_indices, $output_shape, $sparse_values,
    $default_value)>;

def LegalizeUnique : Pat<(TF_UniqueOp $arg0),(TFL_UniqueOp $arg0)>;

def LegalizeFloorMod : Pat<(TF_FloorModOp $arg0, $arg1),

        key_index=lookup_ops.TextFileIndex.WHOLE_LINE,
        value_dtype=dtypes.int64,
        value_index=lookup_ops.TextFileIndex.LINE_NUMBER,
    )
    table = lookup_ops.StaticHashTable(init, default_value=-1)

    input_vocabs_placeholder = array_ops.placeholder(
        dtypes.string, shape=(None,), name='input_vocabs'
    )

    # Introduce a matmul op that takes the lookup values to observe the

dense[i] = (i == sparse_indices ? sparse_values : default_value)

# If sparse_indices is a vector, then for each i
dense[sparse_indices[i]] = sparse_values[i]

# If sparse_indices is an n by d matrix, then for each i in [0, n)
dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
```

All other values in `dense` are set to `default_value`.  If `sparse_values` is a

          name: "config"
          type: "string"
          default_value {
            s: ""
          }
        }
        attr {
          name: "config_proto"
          type: "string"
          default_value {
            s: ""
          }
        }
        attr {
          name: "executor_type"
          type: "string"
          default_value {
            s: ""
          }
        }
      }

}

string OpArgumentView::Initializer() const {
  if (default_value_.empty()) {
    return "";
  }
  return absl::Substitute(" = $0", default_value_);
}

bool OpArgumentView::HasDefaultValue() const { return !default_value_.empty(); }

OpArgumentView::OpArgumentView(string type, string var, string def)
    : type_name_(type), variable_name_(var), default_value_(def) {}

OpArgumentView::OpArgumentView(ArgSpec arg)

The scalar `default_value` is the value output for keys not present in the
table. It must also be of the same type as the table values.
  }];

  let arguments = (ins
    Arg<TF_StrTensor, [{Handle to the table.}], [TF_LookupTableRead]>:$table_handle,
    Arg<TF_Tensor, [{Any shape.  Keys to look up.}]>:$keys,
    TF_Tensor:$default_value
  );

  let results = (outs

    @SuppressWarnings("unchecked") // Assume all default values are generics safe.
    T defaultValue = (T) defaultValues.getInstance(rawType);
    if (defaultValue != null) {
      return defaultValue;
    }
    @SuppressWarnings("unchecked") // ArbitraryInstances always returns generics-safe dummies.
    T value = (T) ArbitraryInstances.get(rawType);
    if (value != null) {
      return value;
    }