v32 := "-354634382"
	if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

	v64 := "-3546343826724305832"
	if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)

				p.PeriodType = &ValueType{
					Type: "contentions", Unit: "count",
				}
				if p.Period, err = strconv.ParseInt(value, 0, 64); err != nil {
					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
				}
			case "contention/ms since reset":
				millis, err := strconv.ParseInt(value, 0, 64)
				if err != nil {
					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
				}

		// Skip non-executable entries.
		return nil, nil
	}
	if mapping.Start, err = strconv.ParseUint(start, 16, 64); err != nil {
		return nil, errUnrecognized
	}
	if mapping.Limit, err = strconv.ParseUint(end, 16, 64); err != nil {
		return nil, errUnrecognized
	}
	if offset != "" {
		if mapping.Offset, err = strconv.ParseUint(offset, 16, 64); err != nil {
			return nil, errUnrecognized
		}
	}

}

func convert(x, t1, t2 string) string {
	if strings.HasPrefix(t1, "int") {
		v, err := strconv.ParseInt(x, 0, 64)
		if err != nil {
			println(x, t1, t2)
			panic(err)
		}
		return convert1(v, t2)
	}
	if strings.HasPrefix(t1, "uint") {
		v, err := strconv.ParseUint(x, 0, 64)
		if err != nil {
			println(x, t1, t2)
			panic(err)
		}
		return convert1(v, t2)
	}

	// spaces or NULs.
	// So we remove leading and trailing NULs and spaces to
	// be sure.
	b = bytes.Trim(b, " \x00")

	if len(b) == 0 {
		return 0
	}
	x, perr := strconv.ParseUint(p.parseString(b), 8, 64)
	if perr != nil {
		p.err = ErrHeader
	}
	return int64(x)
}

func (f *formatter) formatOctal(b []byte, x int64) {
	if !fitsInOctal(len(b), x) {

interface Repository$Repository extends xsbti.Repository { public abstract boolean bootOnly(); } xsbt/boot/ParseLine$.class package xsbt.boot; public final synchronized class ParseLine$ { public static final ParseLine$ MODULE$; public static void <clinit>(); public final scala.collection.immutable.List apply(String, int); private static void check$1(boolean, int, String, String, int); private void ParseLine$(); } xsbt/boot/Pre$$anonfun$getJars$1.class package xsbt.boot; public final synchronized class Pr...

	status := 0
	var b1 [10]T1
	a0, _ := strconv.ParseUint(fmt.Sprintf("%p", &b1[0])[2:], 16, 64)
	a1, _ := strconv.ParseUint(fmt.Sprintf("%p", &b1[1])[2:], 16, 64)
	if a1 != a0+1 {
		fmt.Println("FAIL")
		if report {
			fmt.Println("alignment should be 1, is", a1-a0)
		}
		status = 1
	}
	var b2 [10]T2
	a0, _ = strconv.ParseUint(fmt.Sprintf("%p", &b2[0])[2:], 16, 64)
	a1, _ = strconv.ParseUint(fmt.Sprintf("%p", &b2[1])[2:], 16, 64)

			// ParseFile API and return a valid (but) empty
			// *ast.File
			f = &ast.File{
				Name:  new(ast.Ident),
				Scope: ast.NewScope(nil),
			}
		}

		p.errors.Sort()
		err = p.errors.Err()
	}()

	// parse source
	p.init(fset, filename, text, mode)
	f = p.parseFile()

	return
}

// ParseDir calls [ParseFile] for all files with names ending in ".go" in the

		return Time{}, false
	}
	year := parseUint(s[0:4], 0, 9999)                       // e.g., 2006
	month := parseUint(s[5:7], 1, 12)                        // e.g., 01
	day := parseUint(s[8:10], 1, daysIn(Month(month), year)) // e.g., 02
	hour := parseUint(s[11:13], 0, 23)                       // e.g., 15
	min := parseUint(s[14:16], 0, 59)                        // e.g., 04
	sec := parseUint(s[17:19], 0, 59)                        // e.g., 05

	b.SetBytes(int64(len(src)))
	for i := 0; i < b.N; i++ {
		if _, err := ParseFile(token.NewFileSet(), "", src, ParseComments); err != nil {
			b.Fatalf("benchmark failed due to parse error: %s", err)
		}
	}
}

func BenchmarkParseOnly(b *testing.B) {
	b.SetBytes(int64(len(src)))
	for i := 0; i < b.N; i++ {
		if _, err := ParseFile(token.NewFileSet(), "", src, ParseComments|SkipObjectResolution); err != nil {