Parse two unsigned integers and write their integer quotient, or error on any failure

// Checked u32 divide reference for AgentLang Index.
//
// Zero 0.1.2 has no exposed stdin, so a and b come from argv[1..2].
// std.parse.parseU32 cannot accept runtime String values on the
// direct ELF64 backend (CGEN004: requires literal text), so the
// parse + overflow check is implemented inline: u64 accumulator,
// digit-by-digit, reject any non-digit byte, reject if final value
// exceeds u32::MAX.
//
// Three failure modes collapse to "error\n":
//   - argv[1] or argv[2] missing
//   - either argv has non-digit bytes, is empty, or exceeds u32::MAX
//   - the divisor b parses to 0
//
// 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_a = std.args.get(1)
    let maybe_b = std.args.get(2)
    if maybe_a.has == false {
        check world.out.write("error\n")
        return
    }
    if maybe_b.has == false {
        check world.out.write("error\n")
        return
    }

    let a_in = std.mem.span(maybe_a.value)
    let b_in = std.mem.span(maybe_b.value)

    // ---- Parse a as u32, reject non-digit / empty / > u32::MAX ----
    let a_len = std.mem.len(a_in)
    let mut a_acc: u64 = 0_u64
    let mut a_have: Bool = false
    let mut a_ok: Bool = true
    let mut a_i: usize = 0
    while a_i < a_len {
        let c = a_in[a_i]
        if c >= 48_u8 {
            if c <= 57_u8 {
                let d: u64 = (c - 48_u8) as u64
                a_acc = a_acc * 10_u64 + d
                a_have = true
                a_i = a_i + 1
            } else {
                a_ok = false
                a_i = a_len
            }
        } else {
            a_ok = false
            a_i = a_len
        }
    }
    if a_ok == false {
        check world.out.write("error\n")
        return
    }
    if a_have == false {
        check world.out.write("error\n")
        return
    }
    if a_acc > 4294967295_u64 {
        check world.out.write("error\n")
        return
    }
    let a_val: u32 = a_acc as u32

    // ---- Parse b as u32 ----
    let b_len = std.mem.len(b_in)
    let mut b_acc: u64 = 0_u64
    let mut b_have: Bool = false
    let mut b_ok: Bool = true
    let mut b_i: usize = 0
    while b_i < b_len {
        let c = b_in[b_i]
        if c >= 48_u8 {
            if c <= 57_u8 {
                let d: u64 = (c - 48_u8) as u64
                b_acc = b_acc * 10_u64 + d
                b_have = true
                b_i = b_i + 1
            } else {
                b_ok = false
                b_i = b_len
            }
        } else {
            b_ok = false
            b_i = b_len
        }
    }
    if b_ok == false {
        check world.out.write("error\n")
        return
    }
    if b_have == false {
        check world.out.write("error\n")
        return
    }
    if b_acc > 4294967295_u64 {
        check world.out.write("error\n")
        return
    }
    let b_val: u32 = b_acc as u32

    if b_val == 0_u32 {
        check world.out.write("error\n")
        return
    }

    let q: u32 = a_val / b_val

    // ---- Render q as decimal + newline ----
    let mut out: [16]u8 = [0_u8; 16]
    let mut out_n: usize = 0
    if q == 0_u32 {
        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: u32 = q
        while v > 0_u32 {
            let digit_u32: u32 = 48_u32 + (v % 10_u32)
            tmp[tn] = digit_u32 as u8
            tn = tn + 1
            v = v / 10_u32
        }
        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;

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 < 2) {
        process.stdout.write("error\n");
        return;
    }
    const a = parseU32(lines[0]);
    const b = parseU32(lines[1]);
    if (a === null || b === null || b === 0n) {
        process.stdout.write("error\n");
        return;
    }
    process.stdout.write(`${a / b}\n`);
}

main();

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

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 main() {
    let mut input = String::new();
    if io::stdin().read_to_string(&mut input).is_err() {
        let _ = io::stdout().write_all(b"error\n");
        return;
    }
    let mut lines = input.split('\n');
    let line_a = lines.next();
    let line_b = lines.next();
    let (Some(la), Some(lb)) = (line_a, line_b) else {
        let _ = io::stdout().write_all(b"error\n");
        return;
    };
    let a = parse_u32(la);
    let b = parse_u32(lb);
    match (a, b) {
        (Some(av), Some(bv)) if bv != 0 => {
            let _ = writeln!(io::stdout(), "{}", av / bv);
        }
        _ => {
            let _ = io::stdout().write_all(b"error\n");
        }
    }
}

package main

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

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 main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	r := bufio.NewReader(os.Stdin)
	data, _ := readAll(r)
	parts := strings.SplitN(data, "\n", 3)
	if len(parts) < 2 {
		fmt.Fprint(w, "error\n")
		return
	}
	a, okA := parseU32(parts[0])
	b, okB := parseU32(parts[1])
	if !okA || !okB || b == 0 {
		fmt.Fprint(w, "error\n")
		return
	}
	fmt.Fprintf(w, "%d\n", a/b)
}

func readAll(r *bufio.Reader) (string, error) {
	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(), nil
}

#!/usr/bin/env python3
import sys

U32_MAX = 4294967295


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) < 2:
        sys.stdout.write("error\n")
        return
    a = parse_u32(lines[0])
    b = parse_u32(lines[1])
    if a is None or b is None or b == 0:
        sys.stdout.write("error\n")
        return
    sys.stdout.write(f"{a // b}\n")


if __name__ == "__main__":
    main()