// // the generic type StringInt[T], which maps directly to T.
	// got2 := stringify(x2)
	// want2 := []string{"5", "7", "6"}
	// if !reflect.DeepEqual(got2, want2) {
	// 	panic(fmt.Sprintf("got %s, want %s", got2, want2))
	// }

	// stringify on an instantiated type, whose bound method is associated with
	// the generic type StringStruct[T], which maps to a struct containing T.

  }

  private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
    if (network.isDirected()) {
      Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
      Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
      int selfLoopCount = network.edgesConnecting(node, node).size();
      return network.allowsParallelEdges()

  }

  private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
    if (network.isDirected()) {
      Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
      Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
      int selfLoopCount = network.edgesConnecting(node, node).size();
      return network.allowsParallelEdges()

			data:     []byte(`{"a":` + strings.Repeat(`[`, 3*1024*1024)),
		},
		{
			name:     "3MB of deeply nested maps",
			checkErr: successOrMaxDepthError,
			data:     []byte(strings.Repeat(`{"":`, 3*1024*1024/5/2) + "{}" + strings.Repeat(`}`, 3*1024*1024/5/2)),
		},
		{
			name:     "3MB of unbalanced nested maps",
			checkErr: nonNilError,
			data:     []byte(strings.Repeat(`{"":`, 3*1024*1024/5)),
		},
		{

	"istio.io/istio/pkg/config/schema/collection"
	"istio.io/istio/pkg/config/schema/collections"
	"istio.io/istio/pkg/maps"
)

type FakeStore struct {
	store map[config.GroupVersionKind]map[string]map[string]config.Config
}

func NewFakeStore() *FakeStore {
	f := FakeStore{
		store: make(map[config.GroupVersionKind]map[string]map[string]config.Config),
	}
	return &f
}

var _ ConfigStore = (*FakeStore)(nil)

	"istio.io/istio/pkg/config/schema/gvk"
	"istio.io/istio/pkg/maps"
	"istio.io/istio/pkg/util/protomarshal"
)

type EffectiveProxyConfigResolver struct {
	meshConfig    *meshconfig.MeshConfig
	rootNamespace string
	root          *v1beta1.ProxyConfig
	namespace     map[string]*v1beta1.ProxyConfig
	workload      map[string]*v1beta1.ProxyConfig
}

	}
	// unstructured maps, as seen in annotations
	// map keys must be strings
	if mapOfVal, ok := value.Value().(map[ref.Val]ref.Val); ok {
		result := make(map[string]any)
		for k, v := range mapOfVal {
			stringKey, ok := k.Value().(string)
			if !ok {
				return nil, fmt.Errorf("map key %q is of type %t, not string", k, k)
			}
			result[stringKey] = v.Value()
		}
		return result, nil
	}

        Map<String, String> entries = Maps.fromProperties(properties);
        entries
            .entrySet()
            .stream()
            .filter(entry ->
                !propertyResourceFilter.shouldBeIgnored(entry.getKey()))
            .sorted(Map.Entry.comparingByKey())
            .forEach(entry -> {

type adsConnections struct {
	sync.Mutex

	// keyed by proxy id, then connection id
	byProxy map[proxyKey]map[string]connection
}

func newAdsConnections() *adsConnections {
	return &adsConnections{byProxy: map[proxyKey]map[string]connection{}}
}

func (m *adsConnections) ConnectionsForGroup(wg types.NamespacedName) []connection {

public class HashBasedTable<R, C, V> extends StandardTable<R, C, V> {
  private static class Factory<C, V> implements Supplier<Map<C, V>>, Serializable {
    final int expectedSize;

    Factory(int expectedSize) {
      this.expectedSize = expectedSize;
    }

    @Override
    public Map<C, V> get() {
      return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
    }

    private static final long serialVersionUID = 0;
  }