charts.forEach(chart => {
            renderGraph(
                allDataJson[chart.field],
                {
                    tickFormatter: (index, value) => {
                        if (index === parseInt(index, 10)) { // portable way to check if sth is an integer
                            const executionLabel = allDataJson.executionLabels[index];
                            return executionLabel ? executionLabel.date : "";

	}
	if match[2] != path {
		return BadQuotaID, fmt.Errorf("mismatch between supplied and returned path (%s != %s)", path, match[2])
	}
	projid, err := strconv.ParseInt(match[1], 10, 32)
	if err != nil {
		return BadQuotaID, fmt.Errorf("unable to parse project ID from %s (%v)", match[1], err)
	}
	return QuotaID(projid), nil
}

        return getProperty(propertyName, defaultValue, true);
    }

    private int getProperty(String propertyName, int defaultValue) {
        return Integer.parseInt(getProperty(propertyName, String.valueOf(defaultValue)));
    }

    private boolean getProperty(String propertyName, boolean defaultValue) {

        facetInfo.field = fields;
        facetInfo.query = queries;
        final String sizeStr = request.getParameter("facet.size");
        if (StringUtil.isNotBlank(sizeStr)) {
            facetInfo.size = Integer.parseInt(sizeStr);
        }
        final String minDocCountStr = request.getParameter("facet.minDocCount");
        if (StringUtil.isNotBlank(minDocCountStr)) {
            facetInfo.minDocCount = Long.parseLong(minDocCountStr);

      return;
    }

    String keystoreFile = args[0];
    String password = args[1];
    String root = args[2];
    int port = Integer.parseInt(args[3]);

    SSLContext sslContext = sslContext(keystoreFile, password);
    SampleServer server = new SampleServer(sslContext, root, port);
    server.run();
  }

    private final String className;

    private static final Random RANDOM = new Random();
    private static final int ALL_DIGITS_AND_LETTERS_RADIX = 36;
    private static final int MAX_RANDOM_PART_VALUE = Integer.parseInt("zzzzz", ALL_DIGITS_AND_LETTERS_RADIX);
    private static final Pattern WINDOWS_RESERVED_NAMES = Pattern.compile("(con)|(prn)|(aux)|(nul)|(com\\d)|(lpt\\d)", Pattern.CASE_INSENSITIVE);

    private String prefix;

			match := declareChainRegex.FindStringSubmatch(line)
			if match == nil {
				state = parseChains
				goto retry
			}

			chain := iptables.Chain(match[1])
			packets, _ := strconv.ParseUint(match[2], 10, 64)
			bytes, _ := strconv.ParseUint(match[3], 10, 64)

			t.Chains = append(t.Chains,
				Chain{
					Name:    chain,
					Packets: packets,
					Bytes:   bytes,
				},
			)

		case parseChains:

                "$major.${previous(minor)}"
            }
        }
    }

    private
    fun previous(versionDigit: String) =
        Integer.parseInt(versionDigit) - 1

    private
    val resolver by lazy { projectInternal.newDetachedResolver() }

    private
    val projectInternal
        get() = project as ProjectInternal

    private

	if err != nil && !errors.Is(err, io.EOF) {
		return nil, err
	}
	statLine := strings.TrimSpace(s)
	for _, token := range strings.Fields(statLine) {
		ui64, err := strconv.ParseUint(token, 10, 64)
		if err != nil {
			return nil, err
		}
		stats = append(stats, ui64)
	}

	return stats, nil

        Matcher match = VERSIONED_JAR_ENTRY_PATH.matcher(entryPath);
        if (match.matches()) {
            try {
                int version = Integer.parseInt(match.group(1));
                return OptionalInt.of(version);
            } catch (NumberFormatException ignored) {