Read a count then that many u32 integers and write their sum, or error on any failure

No reference implementation in this language.

const U32_MAX = 4294967295n;
const N_MAX = 1000n;

function parseU32(s: string): bigint | null {
    const t = s.trim();
    if (t.length === 0) return null;
    for (let i = 0; i < t.length; i++) {
        const c = t.charCodeAt(i);
        if (c < 48 || c > 57) return null;
    }
    try {
        const v = BigInt(t);
        if (v > U32_MAX) return null;
        return v;
    } catch {
        return null;
    }
}

async function readAll(): Promise<string> {
    const chunks: Buffer[] = [];
    for await (const chunk of process.stdin) {
        chunks.push(chunk as Buffer);
    }
    return Buffer.concat(chunks).toString("utf8");
}

async function main(): Promise<void> {
    const data = await readAll();
    const lines = data.split("\n");
    if (lines.length < 1) {
        process.stdout.write("error\n");
        return;
    }
    const n = parseU32(lines[0]);
    if (n === null || n > N_MAX) {
        process.stdout.write("error\n");
        return;
    }
    const count = Number(n);
    if (lines.length < count + 1) {
        process.stdout.write("error\n");
        return;
    }
    let total = 0n;
    for (let i = 1; i <= count; i++) {
        const v = parseU32(lines[i]);
        if (v === null) {
            process.stdout.write("error\n");
            return;
        }
        total += v;
        if (total > U32_MAX) {
            process.stdout.write("error\n");
            return;
        }
    }
    process.stdout.write(`${total}\n`);
}

main();

use std::io::{self, Read, Write};

const U32_MAX_U64: u64 = 4294967295;
const N_MAX: u32 = 1000;

fn parse_u32(s: &str) -> Option<u32> {
    let t = s.trim();
    if t.is_empty() {
        return None;
    }
    for b in t.bytes() {
        if !(b'0'..=b'9').contains(&b) {
            return None;
        }
    }
    t.parse::<u32>().ok()
}

fn run() -> Option<u64> {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).ok()?;
    let mut lines = input.split('\n');
    let n_line = lines.next()?;
    let n = parse_u32(n_line)?;
    if n > N_MAX {
        return None;
    }
    let mut total: u64 = 0;
    for _ in 0..n {
        let line = lines.next()?;
        let v = parse_u32(line)? as u64;
        total += v;
        if total > U32_MAX_U64 {
            return None;
        }
    }
    Some(total)
}

fn main() {
    let stdout = io::stdout();
    let mut out = stdout.lock();
    match run() {
        Some(total) => {
            let _ = writeln!(out, "{}", total);
        }
        None => {
            let _ = out.write_all(b"error\n");
        }
    }
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

const u32MaxU64 uint64 = 4294967295
const nMax uint32 = 1000

func parseU32(s string) (uint32, bool) {
	t := strings.TrimSpace(s)
	if t == "" {
		return 0, false
	}
	for _, c := range t {
		if c < '0' || c > '9' {
			return 0, false
		}
	}
	v, err := strconv.ParseUint(t, 10, 32)
	if err != nil {
		return 0, false
	}
	return uint32(v), true
}

func readAll(r *bufio.Reader) string {
	var sb strings.Builder
	buf := make([]byte, 4096)
	for {
		n, err := r.Read(buf)
		if n > 0 {
			sb.Write(buf[:n])
		}
		if err != nil {
			break
		}
	}
	return sb.String()
}

func run(data string) (uint64, bool) {
	lines := strings.Split(data, "\n")
	if len(lines) < 1 {
		return 0, false
	}
	n, ok := parseU32(lines[0])
	if !ok || n > nMax {
		return 0, false
	}
	if uint32(len(lines)) < n+1 {
		return 0, false
	}
	var total uint64 = 0
	for i := uint32(1); i <= n; i++ {
		v, ok := parseU32(lines[i])
		if !ok {
			return 0, false
		}
		total += uint64(v)
		if total > u32MaxU64 {
			return 0, false
		}
	}
	return total, true
}

func main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	data := readAll(bufio.NewReader(os.Stdin))
	total, ok := run(data)
	if !ok {
		fmt.Fprint(w, "error\n")
		return
	}
	fmt.Fprintf(w, "%d\n", total)
}

#!/usr/bin/env python3
import sys

U32_MAX = 4294967295
N_MAX = 1000


def parse_u32(s: str):
    s = s.strip()
    if not s:
        return None
    for ch in s:
        if not ('0' <= ch <= '9'):
            return None
    try:
        v = int(s)
    except ValueError:
        return None
    if v > U32_MAX:
        return None
    return v


def main() -> None:
    data = sys.stdin.read()
    lines = data.split("\n")
    if len(lines) < 1:
        sys.stdout.write("error\n")
        return
    n = parse_u32(lines[0])
    if n is None or n > N_MAX:
        sys.stdout.write("error\n")
        return
    if len(lines) < n + 1:
        sys.stdout.write("error\n")
        return
    total = 0
    for i in range(1, n + 1):
        v = parse_u32(lines[i])
        if v is None:
            sys.stdout.write("error\n")
            return
        total += v
        if total > U32_MAX:
            sys.stdout.write("error\n")
            return
    sys.stdout.write(f"{total}\n")


if __name__ == "__main__":
    main()