"bufio"
	"flag"
	"fmt"
	"log"
	"os"
	"sort"

	"cmd/internal/objfile"
	"cmd/internal/telemetry"
)

const helpText = `usage: go tool nm [options] file...
  -n
      an alias for -sort address (numeric),
      for compatibility with other nm commands
  -size
      print symbol size in decimal between address and type
  -sort {address,name,none,size}
      sort output in the given order (default name)

   *
   * <p><b>Note:</b> This escaper only performs minimal escaping to make content structurally
   * compatible with HTML. Specifically, it does not perform entity replacement (symbolic or
   * numeric), so it does not replace non-ASCII code points with character references. This escaper
   * escapes only the following five ASCII characters: {@code '"&<>}.
   */
  public static Escaper htmlEscaper() {
    return HTML_ESCAPER;

        where:
        versionStr  | parts
        ''          | []
        'a b c'     | ['a b c']
        '...'       | ['', '', '']
        '-a b c-  ' | ['', 'a b c', '  ']
    }

    def "numeric parts are parsed"() {
        expect:
        def version = parse(versionStr)
        version.numericParts == numericParts.collect { it == null ? null : it.toLong() }.toArray()

        where:

	instance   = "test-instance"
	instID     = "987654321"
	zone       = "us-west1-c"

	metaPrefix     = "/computeMetadata/v1"
	projIDPath     = metaPrefix + "/project/project-id"
	projNumberPath = metaPrefix + "/project/numeric-project-id"
	instIDPath     = metaPrefix + "/instance/id"
	instancePath   = metaPrefix + "/instance/name"
	zonePath       = metaPrefix + "/instance/zone"
	attrKey        = "attribute"

var convertibleTypes = []reflect.Type{reflect.TypeOf(time.Time{}), reflect.TypeOf(false), reflect.TypeOf([]byte{})}

// RegEx matches only numeric values
var numericPlaceholderRe = regexp.MustCompile(`\$\d+\$`)

func isNumeric(k reflect.Kind) bool {
	switch k {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return true

		NaNConvert: cbor.NaNConvert7e00,
		InfConvert: cbor.InfConvertFloat16,

		// Prefer encoding math/big.Int to one of the 64-bit integer types if it fits. When
		// later decoded into Unstructured, the set of allowable concrete numeric types is
		// limited to int64 and float64, so the distinction between big integer and integer
		// can't be preserved.
		BigIntConvert: cbor.BigIntConvertShortest,

		// MarshalJSON for time.Time writes RFC3339 with nanos.

#include "tensorflow/compiler/mlir/quantization/common/ir/UniformSupport.h"

#include <cassert>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <iterator>
#include <numeric>

#include "mlir/Dialect/Quant/QuantTypes.h"  // from @llvm-project
#include "mlir/IR/Attributes.h"  // from @llvm-project
#include "mlir/IR/BuiltinAttributeInterfaces.h"  // from @llvm-project

// unmodified.
//
// Given a value of one of Go's predeclared string, bool, or
// (non-complex) numeric types, AnyValue returns a Value of kind
// [KindString], [KindBool], [KindUint64], [KindInt64], or [KindFloat64].
// The width of the original numeric type is not preserved.
//
// Given a [time.Time] or [time.Duration] value, AnyValue returns a Value of kind

type apiLifecycleReplacement interface {
	APILifecycleReplacement() schema.GroupVersionKind
}

// extract all digits at the beginning of the string
var leadingDigits = regexp.MustCompile(`^(\d+)`)

// MajorMinor parses a numeric major/minor version from the provided version info.
// The minor version drops all characters after the first non-digit character:
//
//	version.Info{Major:"1", Minor:"2+"} -> 1,2

	// but broader support for SV57 mode is incomplete,
	// and there may be other issues (see #54104).
	riscv64AddrBits = 56
	riscv64TagBits  = 64 - riscv64AddrBits + 3
)

// The number of bits stored in the numeric tag of a taggedPointer
const taggedPointerBits = (goos.IsAix * aixTagBits) + (goarch.IsRiscv64 * riscv64TagBits) + ((1 - goos.IsAix) * (1 - goarch.IsRiscv64) * tagBits)