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

// Parse-list-sum reference for AgentLang Index.
//
// Zero 0.1.2 has no exposed stdin, so N comes from argv[1] and the N
// values come from argv[2..N+1]. std.args.len() includes the program
// name at index 0. Three failure modes collapse to "error\n":
//   - N argv missing, malformed, or > 1000
//   - fewer than N value argv present
//   - any value argv non-digit / empty / > u32::MAX, OR running sum > u32::MAX
//
// std.parse.parseU* rejects runtime String inputs on the direct ELF64
// backend (CGEN004), so each parse is implemented inline with a u64
// digit-accumulator and a u32::MAX bounds check.
//
// main ends with an explicit `return` to dodge the trailing-write
// byte-count-as-exit-code codegen quirk.

pub fun main(world: World) -> Void raises {
    let maybe_n = std.args.get(1)
    if maybe_n.has == false {
        check world.out.write("error\n")
        return
    }
    let n_in = std.mem.span(maybe_n.value)

    // ---- Parse N as u32, reject > 1000 ----
    let n_len = std.mem.len(n_in)
    let mut n_acc: u64 = 0_u64
    let mut n_have: Bool = false
    let mut n_ok: Bool = true
    let mut n_i: usize = 0
    while n_i < n_len {
        let c = n_in[n_i]
        if c >= 48_u8 {
            if c <= 57_u8 {
                let d: u64 = (c - 48_u8) as u64
                n_acc = n_acc * 10_u64 + d
                n_have = true
                n_i = n_i + 1
            } else {
                n_ok = false
                n_i = n_len
            }
        } else {
            n_ok = false
            n_i = n_len
        }
    }
    if n_ok == false {
        check world.out.write("error\n")
        return
    }
    if n_have == false {
        check world.out.write("error\n")
        return
    }
    if n_acc > 1000_u64 {
        check world.out.write("error\n")
        return
    }
    let n_val: u32 = n_acc as u32

    // ---- Verify std.args.len() >= n_val + 2 (program + N-arg + N values) ----
    let argc = std.args.len()
    let needed: usize = (n_val as usize) + 2_usize
    if argc < needed {
        check world.out.write("error\n")
        return
    }

    // ---- Loop N times: parse argv[i+1] (i in 1..=N), accumulate in u64 ----
    let mut total: u64 = 0_u64
    let mut idx: u32 = 0_u32
    let mut loop_ok: Bool = true
    while idx < n_val {
        let arg_pos: usize = (idx as usize) + 2_usize
        let maybe_v = std.args.get(arg_pos)
        if maybe_v.has == false {
            loop_ok = false
            idx = n_val
        } else {
            let v_in = std.mem.span(maybe_v.value)
            let v_len = std.mem.len(v_in)
            let mut v_acc: u64 = 0_u64
            let mut v_have: Bool = false
            let mut v_ok: Bool = true
            let mut v_i: usize = 0
            while v_i < v_len {
                let c = v_in[v_i]
                if c >= 48_u8 {
                    if c <= 57_u8 {
                        let d: u64 = (c - 48_u8) as u64
                        v_acc = v_acc * 10_u64 + d
                        v_have = true
                        v_i = v_i + 1
                    } else {
                        v_ok = false
                        v_i = v_len
                    }
                } else {
                    v_ok = false
                    v_i = v_len
                }
            }
            if v_ok == false {
                loop_ok = false
                idx = n_val
            } else {
                if v_have == false {
                    loop_ok = false
                    idx = n_val
                } else {
                    if v_acc > 4294967295_u64 {
                        loop_ok = false
                        idx = n_val
                    } else {
                        total = total + v_acc
                        if total > 4294967295_u64 {
                            loop_ok = false
                            idx = n_val
                        } else {
                            idx = idx + 1_u32
                        }
                    }
                }
            }
        }
    }
    if loop_ok == false {
        check world.out.write("error\n")
        return
    }

    // ---- Render total (u64, but constrained to u32 range) as decimal + newline ----
    let mut out: [16]u8 = [0_u8; 16]
    let mut out_n: usize = 0
    if total == 0_u64 {
        out[out_n] = 48_u8
        out_n = out_n + 1
    } else {
        let mut tmp: [16]u8 = [0_u8; 16]
        let mut tn: usize = 0
        let mut v: u64 = total
        while v > 0_u64 {
            let digit_u64: u64 = 48_u64 + (v % 10_u64)
            tmp[tn] = digit_u64 as u8
            tn = tn + 1
            v = v / 10_u64
        }
        let mut wj: usize = 0
        while wj < tn {
            out[out_n] = tmp[tn - 1 - wj]
            out_n = out_n + 1
            wj = wj + 1
        }
    }
    out[out_n] = 10_u8
    out_n = out_n + 1
    check world.out.write(out[0..out_n])
    return
}

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()