// itself, passes the rest on to strconv.ParseFloat.
func myatof64(s string) (f float64, ok bool) {
	if mant, exp, ok := strings.Cut(s, "p"); ok {
		n, err := strconv.ParseInt(mant, 10, 64)
		if err != nil {
			return 0, false
		}
		e, err1 := strconv.Atoi(exp)
		if err1 != nil {
			println("bad e", exp)
			return 0, false
		}
		v := float64(n)

     */

    public static int getInt( String key, int def ) {
        String s = prp.getProperty( key );
        if( s != null ) {
            try {
                def = Integer.parseInt( s );
            } catch( NumberFormatException nfe ) {
                if( log.level > 0 )
                    nfe.printStackTrace( log );
            }
        }
        return def;
    }

    /**

        }
        return trimmed;
    }

    private static int toUnixNumericPermissions(String permissions) {
        try {
            return Integer.parseInt(permissions, 8);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Can't be parsed as octal number.");
        }
    }

		writer.WriteHeader(statusCode)
	}))

	u, _ := url.Parse(server.URL)
	_, p, _ := net.SplitHostPort(u.Host)
	port, _ := strconv.ParseUint(p, 10, 32)

	return server, uint32(port)

func (p *Parser) positiveAtoi(str string) int64 {
	value, err := strconv.ParseInt(str, 0, 64)
	if err != nil {
		p.errorf("%s", err)
	}
	if value < 0 {
		p.errorf("%s overflows int64", str)
	}
	return value
}

func (p *Parser) atoi(str string) uint64 {
	value, err := strconv.ParseUint(str, 0, 64)
	if err != nil {
		p.errorf("%s", err)
	}
	return value
}

			return
		}
	}
	scanner := bufio.NewScanner(reader)
	for scanner.Scan() { //gdb-opt=(scanner/A)
		s := scanner.Text()
		i, err := strconv.ParseInt(s, 10, 64)
		if err != nil { //gdb-dbg=(i) //gdb-opt=(err,hist,i)
			fmt.Fprintf(os.Stderr, "There was an error: %v\n", err)
			return
		}
		hist = ensure(int(i), hist)
		hist[int(i)]++
	}
	t := 0
	n := 0

        lines.find { it == heading } // here for nicer output if the output isn't what we expect
        def headingIndex = lines.indexOf(heading)
        def classpathSize = Integer.parseInt(lines[headingIndex + 1])
        // The gradle-launcher.jar is mandatory.
        // The gradle-instrumentation-agent.jar may not be available if the build runs in no-daemon mode.

        final List<String> hostPortList = DfStringUtil.splitListTrimmed(hostAndPort, ":");
        motorbike.registerConnectionInfo(hostPortList.get(0), Integer.parseInt(hostPortList.get(1)));
        motorbike.registerReturnPath(fessConfig.getMailReturnPath());
        parkingLot.registerMotorbikeAsMain(motorbike);
        return parkingLot;
    }

        String expected = "1";
        doc.put("key1", expected);
        assertEquals(expected, DocumentUtil.getValue(doc, "key1", String.class));
        assertEquals(Integer.parseInt(expected), DocumentUtil.getValue(doc, "key1", Integer.class).intValue());
        assertEquals(Long.parseLong(expected), DocumentUtil.getValue(doc, "key1", Long.class).longValue());

	var gotStmts []int
	var gotStacks [][]int
	for dump.Scan() {
		line := dump.Text()
		dumpLineNum++
		matches := inlineLine.FindStringSubmatch(line)
		if len(matches) == 2 {
			stmt, err := strconv.ParseInt(matches[1], 10, 32)
			if err != nil {
				t.Fatalf("Expected to parse a line number but saw %s instead on dump line #%d, error %v", matches[1], dumpLineNum, err)
			}
			if testing.Verbose() {