bothInBounds := list1Inbounds && list2Inbounds
	switch {
	// scalars are identical
	case bothInBounds && list1Value == list2Value:
		return nil, nil
	// only list2 is in bound
	case !list1Inbounds:
		fallthrough
	// list2 has additional scalar
	case bothInBounds && list1Value > list2Value:
		return nil, list2Value

              "ConfigType": {
                "Config": {
                  "fields": {
                    "access_log": {
                      "Kind": {
                        "ListValue": {
                          "values": [
                            {
                              "Kind": {
                                "StructValue": {
                                  "fields": {

package main

func Float64D3(list [][][]float64, value float64) int {
	valueCount := 0
	for _, listValue := range list {
		valueCount += Float64D2(listValue, value)
	}
	return valueCount
}

func Float64(list []float64, value float64) int {
	valueCount := 0
	for _, listValue := range list {
		if listValue == value {
			valueCount++
		}
	}
	return valueCount
}

              "ConfigType": {
                "Config": {
                  "fields": {
                    "access_log": {
                      "Kind": {
                        "ListValue": {
                          "values": [
                            {
                              "Kind": {
                                "StructValue": {
                                  "fields": {

func.func @main() {
^bb0:
  // CHECK:      key: "listvalue"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   list {
  // CHECK-NEXT:     s: " \n"
  // CHECK-NEXT:   }
  // CHECK:      key: "value"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   s: " 0\n\000\000"
  tf_executor.graph {
    %0:2 = tf_executor.island wraps "tf.Placeholder"() {name = "dummy", dtype = "tfdtype$DT_INT32", value = "\200\n\00\00", listvalue = ["\20\0A"]} : () -> tensor<2xi32>

type Field struct {
	ID   int64
	Name string
	Ref  *DynValue
}

// NewListValue returns an empty ListValue instance.
func NewListValue() *ListValue {
	return &ListValue{
		Entries: []*DynValue{},
	}
}

// ListValue contains a list of dynamically typed entries.
type ListValue struct {
	Entries      []*DynValue
	initValueSet sync.Once
	valueSet     map[ref.Val]struct{}
}

    function_spec {
      fullargspec {
        named_tuple_value {
          name: "FullArgSpec"
          values {
            key: "args"
            value {
              list_value {
              }
            }
          }
          values {
            key: "varargs"
            value {
              none_value {
              }
            }
          }

	// Ensure VIP cluster has services metadata for stats filter usage
	im := getOrCreateIstioMetadata(localCluster.cluster)
	im.Fields["services"] = &structpb.Value{
		Kind: &structpb.Value_ListValue{
			ListValue: &structpb.ListValue{
				Values: []*structpb.Value{},
			},
		},
	}
	svcMetaList := im.Fields["services"].GetListValue()
	svcMetaList.Values = append(svcMetaList.Values, buildServiceMetadata(svc))

        TF_RETURN_IF_ERROR(FlattenSignature(value, flattened_specs));
      }
      return Status();
    }
    case StructuredValue::kListValue: {
      const ListValue& list = signature.list_value();
      for (const StructuredValue& value : list.values()) {
        TF_RETURN_IF_ERROR(FlattenSignature(value, flattened_specs));
      }
      return Status();
    }

}

string PrintTensor(const TensorProto& tensor_proto);

string PrintTensorProto(const TensorProto& proto);

string PrintAttrValue(StringPiece, const AttrValue& attr_value);

bool IsEmptyList(const AttrValue::ListValue& list);

string ToCamelCase(StringPiece str);

string SeparateNamespaces(StringPiece str);

// Returns a <string, bool> pair. The string is the C++ type name to be used for