% Benchmark: bigint arithmetic (division/mod/rem, shifts, bitwise ops).
% Uses chunked loops to reduce recursion depth; very large totals can still
% exceed FLOWLOG_DEPTH_LIMIT in interp/wam (bench script caps by default).

bigints(A, B, C) :-
    A is 2^200 + 1234567,
    B is 2^160 + 76543,
    C is 2^240 + 17.

chunk_size(1024).

loop_ops(N, _, _, _, _) :-
    N =< 0,
    !.
loop_ops(N, A, B, C, NA) :-
    chunk_size(Chunk),
    (   N =< Chunk
    ->  loop_ops_inner(N, A, B, C, NA)
    ;   loop_ops_inner(Chunk, A, B, C, NA),
        N1 is N - Chunk,
        loop_ops(N1, A, B, C, NA)
    ).

loop_ops_inner(0, _, _, _, _) :- !.
loop_ops_inner(N, A, B, C, NA) :-
    Q1 is A div B,
    R1 is A mod B,
    R2 is A rem B,
    Q2 is (A + C) // B,
    Q3 is (A * 3) div B,
    BW1 is A /\ C,
    BW2 is A \/ C,
    BW3 is A xor C,
    BW4 is NA /\ C,
    BW5 is NA \/ C,
    BW6 is NA xor C,
    S1 is A << 13,
    S2 is C >> 7,
    _ = (Q1, R1, R2, Q2, Q3, BW1, BW2, BW3, BW4, BW5, BW6, S1, S2),
    N1 is N - 1,
    loop_ops_inner(N1, A, B, C, NA).

bench(Iter, Batch) :-
    Iter >= 0,
    Batch >= 0,
    bigints(A, B, C),
    NA is -A,
    Total is Iter * Batch,
    loop_ops(Total, A, B, C, NA).