return Sizes(s)
		}
	case "gccgo":
		if s, ok := gccgoArchSizes[arch]; ok {
			return Sizes(s)
		}
	}
	return nil
}

// stdSizes is used if Config.Sizes == nil.
var stdSizes = SizesFor("gc", "amd64")

func (conf *Config) alignof(T Type) int64 {
	f := stdSizes.Alignof
	if conf.Sizes != nil {
		f = conf.Sizes.Alignof
	}
	if a := f(T); a >= 1 {

			return Sizes(s)
		}
	case "gccgo":
		if s, ok := gccgoArchSizes[arch]; ok {
			return Sizes(s)
		}
	}
	return nil
}

// stdSizes is used if Config.Sizes == nil.
var stdSizes = SizesFor("gc", "amd64")

func (conf *Config) alignof(T Type) int64 {
	f := stdSizes.Alignof
	if conf.Sizes != nil {
		f = conf.Sizes.Alignof
	}
	if a := f(T); a >= 1 {

bells17 <******@****.***> 1713555590 +0900

)

func TestSizeHistogramToMap(t *testing.T) {
	tests := []struct {
		sizes []int64
		want  map[string]uint64
	}{
		{
			sizes: []int64{100, 1000, 72_000, 100_000},
			want: map[string]uint64{
				"LESS_THAN_1024_B":         2,
				"BETWEEN_64_KB_AND_256_KB": 2,
				"BETWEEN_1024B_AND_1_MB":   2,
			},
		},
		{
			sizes: []int64{100, 1000, 2000, 100_000, 13 * humanize.MiByte},
			want: map[string]uint64{

		}
	default:
		structuralTypes = append(structuralTypes, t)
	}
	sizes := make(map[int64]struct{})
	for _, t := range structuralTypes {
		size := 8 * pass.TypesSizes.Sizeof(t)
		sizes[size] = struct{}{}
	}
	minSize := int64(math.MaxInt64)
	for size := range sizes {
		if size < minSize {
			minSize = size
		}
	}
	if amt >= minSize {

// size might have a 26.6% (1.266x) overhead.
// In practice, only one of the wastes comes into play for a
// given size (sizes < 512 waste mainly on the round-up,
// sizes > 512 waste mainly on the page chopping).
// For really small sizes, alignment constraints force the
// overhead higher.

package main

import (
	"bytes"
	"flag"
	"fmt"
	"go/format"
	"io"
	"log"
	"math"

		// Type parameters lead to variable sizes/alignments;
		// StdSizes.Sizeof won't be called for them.
		assert(!isTypeParam(T))
		return s.WordSize * 2
	case *TypeParam, *Union:
		panic("unreachable")
	}
	return s.WordSize // catch-all
}

// gcSizesFor returns the Sizes used by gc for an architecture.
// The result is a nil *gcSizes pointer (which is not a valid types.Sizes)

		// Type parameters lead to variable sizes/alignments;
		// StdSizes.Sizeof won't be called for them.
		assert(!isTypeParam(T))
		return s.WordSize * 2
	case *TypeParam, *Union:
		panic("unreachable")
	}
	return s.WordSize // catch-all
}

// gcSizesFor returns the Sizes used by gc for an architecture.
// The result is a nil *gcSizes pointer (which is not a valid types.Sizes)

  MLIR input.
* `--input-arg-shapes`: A string representation of input argument shapes for
  'main' entry-point, separating tensors with ':', dimension with ',', and
  using '?' for unknown sizes. For example, `input-arg-shapes=1,2::1,?`
  expresses argument shapes `[1,2]`, `[]` and `[1,?]`.
* `--e`: Elide large elements attrs while dumping the output StableHLO.

//    SavedModel.
//   input_arg_shapes_str: A string representation of input argument
//    shapes for 'main' entry-point, separating tensors with ':', dimension
//    with ',', and using '?' for unknown sizes. For example,
//    'input-arg-shapes=1,2::1,?' expresses argument shapes [1,2], [] and [1,?].
//
// Returns:
//   An absl::StatusOr containing the serialized bytecode of the StableHLO