namespace {

constexpr absl::string_view kZeroArgInputSignatureTextProto = R"(
tuple_value: {
    values: {
      tuple_value: {
      }
    }
    values: {
      dict_value: {
      }
    }
}
)";

constexpr absl::string_view kSingleArgInputSignatureTextProto = R"(
tuple_value: {
    values: {
    tuple_value: {
        values: {
        tensor_spec_value: {
            name : "x"

            }
          }
        }
      }
      input_signature {
        tuple_value {
        }
      }
    }
  }
}
concrete_functions {
  key: "__inference_my_func_5"
  value {
    canonicalized_input_signature {
      tuple_value {
        values {
          tuple_value {
          }
        }
        values {
          dict_value {
          }
        }

        const RepeatedPtrField<StructuredValue>& args =
            saved_concrete_function.canonicalized_input_signature()
                .tuple_value()
                .values(0)
                .tuple_value()
                .values();
        for (const StructuredValue& arg : args) {
          PartialTensorShape shape = arg.tensor_spec_value().shape();

        "of form tuple(tuple(), dict()), but was instead: \n",
        canonicalized_input_signature.DebugString()));
  }

  const TupleValue& args_kwargs_tuple =
      canonicalized_input_signature.tuple_value();
  if (args_kwargs_tuple.values_size() != 2) {
    return absl::FailedPreconditionError(absl::StrCat(
        "SignatureDefFunction's canonicalized_input_signature should be "

      for (const auto& entry : entries) {
        TF_RETURN_IF_ERROR(FlattenSignature(entry->second, flattened_specs));
      }
      return Status();
    }
    case StructuredValue::kTupleValue: {
      const TupleValue& tuple = signature.tuple_value();
      for (const StructuredValue& value : tuple.values()) {
        TF_RETURN_IF_ERROR(FlattenSignature(value, flattened_specs));
      }
      return Status();
    }

    }
    concrete_functions {
      key: "__inference_<lambda>_18"
      value {
        bound_inputs: 5
        canonicalized_input_signature {
          tuple_value {
            values {
              tuple_value {
              }
            }
            values {
              dict_value {
              }
            }
          }
        }
        output_signature {

        RecursivelyFindLeaves(field->second);
        current_index_path_.pop_back();
      }
      return;
    }
    case StructuredValue::kTupleValue: {
      const TupleValue& tuple = value.tuple_value();
      for (int i = 0, e = tuple.values_size(); i < e; i++) {
        current_index_path_.push_back(builder_.getI64IntegerAttr(i));
        RecursivelyFindLeaves(tuple.values(i));

      Parameter(&xla_builder, 0, ShapeUtil::MakeScalarShape(xla::F32), "a");

  XlaOp add = xla::Add(param, xla::ConstantR0<float>(&xla_builder, 2.0));

  std::vector<XlaOp> tuple_values;
  tuple_values.push_back(add);

  xla::Tuple(&xla_builder, tuple_values);
  return xla_builder.Build().value();
}

class EmptyPatternRewriter : public mlir::PatternRewriter {
 public:
  explicit EmptyPatternRewriter(const OpBuilder& other_builder)