module main

import math
import os
import sync
import strings
import v3.bench
import v.token

// Cat represents cat data used by v3 tests.
struct Cat {
    name string
    age  int
}

// Dog represents dog data used by v3 tests.
struct Dog {
    name   string
    tricks int
}

// Animal aliases animal values used by v3 tests.
type Animal = Cat | Dog

// UserId104 aliases user id104 values used by v3 tests.
type UserId104 = int

// Holder represents holder data used by v3 tests.
struct Holder {
mut:
    pet Animal
}

// describe_holder supports describe holder handling for v3 tests.
fn describe_holder(h Holder) string {
    if h.pet is Cat {
        return h.pet.name
    } else if h.pet is Dog {
        return h.pet.name
    }
    return 'unknown'
}

// holder_detail supports holder detail handling for v3 tests.
fn holder_detail(h Holder) int {
    match h.pet {
        Cat {
            return h.pet.age
        }
        Dog {
            return h.pet.tricks
        }
    }

    return 0
}

// Point represents point data used by v3 tests.
struct Point {
mut:
    x int
    y int
}

// Node represents node data used by v3 tests.
struct Node {
mut:
    value int
    left  int
    right int
}

// Rectangle represents rectangle data used by v3 tests.
struct Rectangle {
mut:
    width  int
    height int
    origin Point
}

__global (
    g_val    int
    g_count  int
    g_flag   bool
    g_point  Point
    g_vec    Vec3
    g_acc    int
    g_toggle bool
)

// ===================== HELPER FUNCTIONS =====================

// fib supports fib handling for v3 tests.
fn fib(n int) int {
    if n < 2 {
        return n
    }
    return fib(n - 1) + fib(n - 2)
}

// factorial supports factorial handling for v3 tests.
fn factorial(n int) int {
    if n <= 1 {
        return 1
    }
    return n * factorial(n - 1)
}

// sum_recursive supports sum recursive handling for v3 tests.
fn sum_recursive(n int) int {
    if n <= 0 {
        return 0
    }
    return n + sum_recursive(n - 1)
}

// Foo97 represents foo97 data used by v3 tests.
struct Foo97 {
    x    int
    y    int
    name string
    val  int
}

// new creates a Foo97 value for v3 tests.
fn Foo97.new(x int, y int) Foo97 {
    return Foo97{
        x: x
        y: y
    }
}

// with_name supports with name handling for Foo97.
fn Foo97.with_name(name string, val int) Foo97 {
    return Foo97{
        name: name
        val:  val
    }
}

// multiply supports multiply handling for v3 tests.
fn multiply(a int, b int) int {
    return a * b
}

// apply_op supports apply op handling for v3 tests.
fn apply_op(f fn (int, int) int, x int, y int) int {
    return f(x, y)
}

// gcd supports gcd handling for v3 tests.
fn gcd(a int, b int) int {
    if b == 0 {
        return a
    }
    return gcd(b, a % b)
}

// power supports power handling for v3 tests.
fn power(base int, exp int) int {
    if exp == 0 {
        return 1
    }
    return base * power(base, exp - 1)
}

// add updates add state for v3 tests.
fn add(a int, b int) int {
    return a + b
}

// sub supports sub handling for v3 tests.
fn sub(a int, b int) int {
    return a - b
}

// mul supports mul handling for v3 tests.
fn mul(a int, b int) int {
    return a * b
}

// print_rec updates print rec state for v3 tests.
fn print_rec(n int) {
    if n == 0 {
        return
    }
    print_rec(n / 10)
    rem := n - (n / 10) * 10
    C.putchar(rem + 48)
}

// print_int updates print int state for v3 tests.
fn print_int(n int) {
    if n == 0 {
        C.putchar(48)
        C.putchar(10)
        return
    }
    mut v := n
    if n < 0 {
        C.putchar(45)
        v = 0 - n
    }
    print_rec(v)
    C.putchar(10)
}

// print_str updates print str state for v3 tests.
fn print_str(s string) {
    C.puts(s.str)
}

// repeat supports repeat handling for v3 tests.
fn repeat(c u8, n int) int {
    if c == `x` && n == 3 {
        return 8
    }
    return 0
}

// next_in_value returns next in value data for v3 tests.
fn next_in_value() int {
    g_count = g_count + 1
    return g_count
}

// maybe_review_value supports maybe review value handling for v3 tests.
fn maybe_review_value(ok bool) ?int {
    if ok {
        return 42
    }
    return none
}

// optional_arg_int104 supports optional arg int104 handling for v3 tests.
fn optional_arg_int104(x ?int) int {
    return x or { -1 }
}

// optional_arg_point104 supports optional arg point104 handling for v3 tests.
fn optional_arg_point104(p ?Point) int {
    pt := p or { return -1 }
    return pt.x + pt.y
}

// make_review_animal builds make review animal data for v3 tests.
fn make_review_animal() Animal {
    return Cat{
        name: 'Milo'
        age:  4
    }
}

// next supports next handling for UserId104.
fn (id UserId104) next() int {
    return int(id) + 1
}

// sum_many supports sum many handling for v3 tests.
fn sum_many(a int, b int, c int, d int, e int, f int, g int, h int) int {
    return a + b + c + d + e + f + g + h
}

// mul_many supports mul many handling for v3 tests.
fn mul_many(a int, b int, c int, d int, e int, f int, g int, h int) int {
    return a * b * c * d * e * f * g * h
}

// max_of_eight supports max of eight handling for v3 tests.
fn max_of_eight(a int, b int, c int, d int, e int, f int, g int, h int) int {
    mut m := a
    if b > m {
        m = b
    }
    if c > m {
        m = c
    }
    if d > m {
        m = d
    }
    if e > m {
        m = e
    }
    if f > m {
        m = f
    }
    if g > m {
        m = g
    }
    if h > m {
        m = h
    }
    return m
}

// weighted_sum supports weighted sum handling for v3 tests.
fn weighted_sum(a int, b int, c int, d int, e int, f int, g int, h int) int {
    return a * 1 + b * 2 + c * 3 + d * 4 + e * 5 + f * 6 + g * 7 + h * 8
}

// Color represents color data used by v3 tests.
struct Color {
mut:
    r int
    g int
    b int
    a int
}

// Vec3 represents vec3 data used by v3 tests.
struct Vec3 {
mut:
    x int
    y int
    z int
}

// Matrix2x2 represents matrix2x2 data used by v3 tests.
struct Matrix2x2 {
mut:
    a int
    b int
    c int
    d int
}

// LinkedNode represents linked node data used by v3 tests.
struct LinkedNode {
mut:
    val  int
    next int
}

// Stats represents stats data used by v3 tests.
struct Stats {
mut:
    min_v int
    max_v int
    sum   int
    count int
}

// make_point builds make point data for v3 tests.
fn make_point(px int, py int) Point {
    return Point{
        x: px
        y: py
    }
}

// add_points updates add points state for v3 tests.
fn add_points(a Point, b Point) Point {
    return Point{
        x: a.x + b.x
        y: a.y + b.y
    }
}

// abs_val supports abs val handling for v3 tests.
fn abs_val(n int) int {
    if n < 0 {
        return 0 - n
    }
    return n
}

// min_val supports min val handling for v3 tests.
fn min_val(a int, b int) int {
    if a < b {
        return a
    }
    return b
}

// max_val supports max val handling for v3 tests.
fn max_val(a int, b int) int {
    if a > b {
        return a
    }
    return b
}

// clamp supports clamp handling for v3 tests.
fn clamp(val int, lo int, hi int) int {
    if val < lo {
        return lo
    }
    if val > hi {
        return hi
    }
    return val
}

// collatz_steps supports collatz steps handling for v3 tests.
fn collatz_steps(start int) int {
    mut v := start
    mut steps := 0
    for v != 1 {
        if v % 2 == 0 {
            v = v / 2
        } else {
            v = v * 3 + 1
        }
        steps++
    }
    return steps
}

// sum_digits supports sum digits handling for v3 tests.
fn sum_digits(n int) int {
    mut v := n
    if v < 0 {
        v = 0 - v
    }
    mut s := 0
    for v > 0 {
        s += v % 10
        v = v / 10
    }
    return s
}

// count_bits supports count bits handling for v3 tests.
fn count_bits(n int) int {
    mut v := n
    mut count := 0
    for v != 0 {
        count += v & 1
        v = v >> 1
    }
    return count
}

// classify supports classify handling for v3 tests.
fn classify(n int) int {
    if n > 100 {
        return 3
    } else if n > 50 {
        return 2
    } else if n > 0 {
        return 1
    } else {
        return 0
    }
}

// point_quadrant supports point quadrant handling for v3 tests.
fn point_quadrant(p Point) int {
    if p.x > 0 && p.y > 0 {
        return 1
    } else if p.x < 0 && p.y > 0 {
        return 2
    } else if p.x < 0 && p.y < 0 {
        return 3
    } else if p.x > 0 && p.y < 0 {
        return 4
    } else {
        return 0
    }
}

// make_color builds make color data for v3 tests.
fn make_color(r int, g int, b int, a int) Color {
    return Color{
        r: r
        g: g
        b: b
        a: a
    }
}

// color_brightness supports color brightness handling for v3 tests.
fn color_brightness(c Color) int {
    return (c.r + c.g + c.b) / 3
}

// scale_rect supports scale rect handling for v3 tests.
fn scale_rect(mut r Rectangle, factor int) {
    r.width = r.width * factor
    r.height = r.height * factor
}

// modify_struct supports modify struct handling for v3 tests.
fn modify_struct(mut p Point) {
    p.x = 999
    p.y = 888
}

// swap_point supports swap point handling for v3 tests.
fn swap_point(mut p Point) {
    tmp := p.x
    p.x = p.y
    p.y = tmp
}

// scale_point supports scale point handling for v3 tests.
fn scale_point(mut p Point, factor int) {
    p.x = p.x * factor
    p.y = p.y * factor
}

// translate_point supports translate point handling for v3 tests.
fn translate_point(mut p Point, dx int, dy int) {
    p.x = p.x + dx
    p.y = p.y + dy
}

// reset_point updates reset point state for v3 tests.
fn reset_point(mut p Point) {
    p.x = 0
    p.y = 0
}

// vec3_dot supports vec3 dot handling for v3 tests.
fn vec3_dot(a Vec3, b Vec3) int {
    return a.x * b.x + a.y * b.y + a.z * b.z
}

// vec3_cross_z supports vec3 cross z handling for v3 tests.
fn vec3_cross_z(a Vec3, b Vec3) int {
    return a.x * b.y - a.y * b.x
}

// vec3_len_sq supports vec3 len sq handling for v3 tests.
fn vec3_len_sq(v Vec3) int {
    return v.x * v.x + v.y * v.y + v.z * v.z
}

// vec3_add supports vec3 add handling for v3 tests.
fn vec3_add(a Vec3, b Vec3) Vec3 {
    return Vec3{
        x: a.x + b.x
        y: a.y + b.y
        z: a.z + b.z
    }
}

// vec3_scale supports vec3 scale handling for v3 tests.
fn vec3_scale(v Vec3, s int) Vec3 {
    return Vec3{
        x: v.x * s
        y: v.y * s
        z: v.z * s
    }
}

// mat_det supports mat det handling for v3 tests.
fn mat_det(m Matrix2x2) int {
    return m.a * m.d - m.b * m.c
}

// mat_mul supports mat mul handling for v3 tests.
fn mat_mul(m Matrix2x2, n Matrix2x2) Matrix2x2 {
    return Matrix2x2{
        a: m.a * n.a + m.b * n.c
        b: m.a * n.b + m.b * n.d
        c: m.c * n.a + m.d * n.c
        d: m.c * n.b + m.d * n.d
    }
}

// mat_trace supports mat trace handling for v3 tests.
fn mat_trace(m Matrix2x2) int {
    return m.a + m.d
}

// is_prime reports whether is prime applies in v3 tests.
fn is_prime(n int) bool {
    if n < 2 {
        return false
    }
    mut i := 2
    for i * i <= n {
        if n % i == 0 {
            return false
        }
        i++
    }
    return true
}

// isqrt supports isqrt handling for v3 tests.
fn isqrt(n int) int {
    if n <= 0 {
        return 0
    }
    mut x := n
    mut y := (x + 1) / 2
    for y < x {
        x = y
        y = (x + n / x) / 2
    }
    return x
}

// reverse_int supports reverse int handling for v3 tests.
fn reverse_int(n int) int {
    mut v := n
    mut neg := false
    if v < 0 {
        neg = true
        v = 0 - v
    }
    mut result := 0
    for v > 0 {
        result = result * 10 + v % 10
        v = v / 10
    }
    if neg {
        return 0 - result
    }
    return result
}

// count_digits supports count digits handling for v3 tests.
fn count_digits(n int) int {
    if n == 0 {
        return 1
    }
    mut v := n
    if v < 0 {
        v = 0 - v
    }
    mut count := 0
    for v > 0 {
        count++
        v = v / 10
    }
    return count
}

// is_palindrome_num reports whether is palindrome num applies in v3 tests.
fn is_palindrome_num(n int) bool {
    if n < 0 {
        return false
    }
    return n == reverse_int(n)
}

// update_stats supports update stats handling for v3 tests.
fn update_stats(mut s Stats, val int) {
    if s.count == 0 || val < s.min_v {
        s.min_v = val
    }
    if s.count == 0 || val > s.max_v {
        s.max_v = val
    }
    s.sum += val
    s.count++
}

// binary_search_step supports binary search step handling for v3 tests.
fn binary_search_step(target int, lo int, hi int, a0 int, a1 int, a2 int, a3 int, a4 int) int {
    if lo > hi {
        return 0 - 1
    }
    mid := (lo + hi) / 2
    mut mid_val := 0
    if mid == 0 {
        mid_val = a0
    } else if mid == 1 {
        mid_val = a1
    } else if mid == 2 {
        mid_val = a2
    } else if mid == 3 {
        mid_val = a3
    } else {
        mid_val = a4
    }

    if mid_val == target {
        return mid
    } else if mid_val < target {
        return binary_search_step(target, mid + 1, hi, a0, a1, a2, a3, a4)
    }
    return binary_search_step(target, lo, mid - 1, a0, a1, a2, a3, a4)
}

// ackermann supports ackermann handling for v3 tests.
fn ackermann(m int, n int) int {
    if m == 0 {
        return n + 1
    }
    if n == 0 {
        return ackermann(m - 1, 1)
    }
    return ackermann(m - 1, ackermann(m, n - 1))
}

// triangle_area_2x supports triangle area 2x handling for v3 tests.
fn triangle_area_2x(x1 int, y1 int, x2 int, y2 int, x3 int, y3 int) int {
    area := x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)
    if area < 0 {
        return 0 - area
    }
    return area
}

// rotate_point_90 supports rotate point 90 handling for v3 tests.
fn rotate_point_90(p Point) Point {
    return Point{
        x: 0 - p.y
        y: p.x
    }
}

// manhattan_dist supports manhattan dist handling for v3 tests.
fn manhattan_dist(a Point, b Point) int {
    mut dx := a.x - b.x
    mut dy := a.y - b.y
    if dx < 0 {
        dx = 0 - dx
    }
    if dy < 0 {
        dy = 0 - dy
    }
    return dx + dy
}

// digital_root supports digital root handling for v3 tests.
fn digital_root(n int) int {
    mut v := n
    if v < 0 {
        v = 0 - v
    }
    for v >= 10 {
        v = sum_digits(v)
    }
    return v
}

// lerp supports lerp handling for v3 tests.
fn lerp(a int, b int, t_num int, t_den int) int {
    return a + (b - a) * t_num / t_den
}

// sign supports sign handling for v3 tests.
fn sign(n int) int {
    if n > 0 {
        return 1
    } else if n < 0 {
        return 0 - 1
    }
    return 0
}

// popcount_loop supports popcount loop handling for v3 tests.
fn popcount_loop(n int) int {
    mut v := n
    mut c := 0
    for v != 0 {
        v = v & (v - 1)
        c++
    }
    return c
}

// leading_zeros supports leading zeros handling for v3 tests.
fn leading_zeros(n int) int {
    if n == 0 {
        return 32
    }
    mut v := n
    mut count := 0
    mut mask := 1 << 30
    for mask > 0 {
        if v & mask != 0 {
            return count
        }
        count++
        mask = mask >> 1
    }
    return count
}

// ===================== METHODS =====================

// sum supports sum handling for Point.
fn (p Point) sum() int {
    return p.x + p.y
}

// product supports product handling for Point.
fn (p Point) product() int {
    return p.x * p.y
}

// double supports double handling for Point.
fn (mut p Point) double() {
    p.x = p.x * 2
    p.y = p.y * 2
}

// area supports area handling for Rectangle.
fn (r Rectangle) area() int {
    return r.width * r.height
}

// perimeter supports perimeter handling for Rectangle.
fn (r Rectangle) perimeter() int {
    return 2 * (r.width + r.height)
}

// total supports total handling for Node.
fn (n Node) total() int {
    return n.value + n.left + n.right
}

// ===================== IF-EXPRESSION HELPERS =====================

// int_abs supports int abs handling for v3 tests.
fn int_abs(a int) int {
    return if a < 0 { 0 - a } else { a }
}

// int_max2 supports int max2 handling for v3 tests.
fn int_max2(a int, b int) int {
    return if a > b { a } else { b }
}

// int_min2 supports int min2 handling for v3 tests.
fn int_min2(a int, b int) int {
    return if a < b { a } else { b }
}

// sign_expr supports sign expr handling for v3 tests.
fn sign_expr(x int) int {
    return if x < 0 {
        0 - 1
    } else {
        if x > 0 {
            1
        } else {
            0
        }
    }
}

// clamp_expr supports clamp expr handling for v3 tests.
fn clamp_expr(x int, lo int, hi int) int {
    return if x < lo {
        lo
    } else {
        if x > hi {
            hi
        } else {
            x
        }
    }
}

// ===================== DEFER HELPERS =====================

// defer_return_test supports defer return test handling for v3 tests.
fn defer_return_test() int {
    defer {
        g_acc += 100
    }
    return 42
}

// defer_order_test supports defer order test handling for v3 tests.
fn defer_order_test() {
    defer { g_acc += 1 }
    defer { g_acc += 10 }
    defer { g_acc += 100 }
}

// ===================== ENUMS =====================

// nested_return supports nested return handling for v3 tests.
fn nested_return(x int) int {
    if x < 10 {
        return 100
    } else {
        if x < 20 {
            return 200
        } else {
            return 300
        }
    }
}

// operator_to_name converts operator to name data for v3 tests.
fn operator_to_name(op string) string {
    return match op {
        '+' { '__plus' }
        '-' { '__minus' }
        '*' { '__mul' }
        '/' { '__div' }
        else { op }
    }
}

// get_type_name returns get type name data for v3 tests.
fn get_type_name(is_signed bool, size int) string {
    return if is_signed {
        match size {
            8 { 'i8' }
            16 { 'i16' }
            32 { 'int' }
            64 { 'i64' }
            else { 'int' }
        }
    } else {
        match size {
            8 { 'u8' }
            16 { 'u16' }
            32 { 'u32' }
            else { 'u64' }
        }
    }
}

// test_return_if_expr validates return if expr behavior in v3 tests.
fn test_return_if_expr() {
    assert get_type_name(true, 32) == 'int'
    assert get_type_name(false, 64) == 'u64'
    assert get_type_name(true, 8) == 'i8'
    assert get_type_name(false, 16) == 'u16'
    print_str('return if expr: ok')
}

// Direction lists direction values used by v3 tests.
enum Direction {
    up
    down
    left
    right
}

// ===================== MULTI-RETURN FUNCTIONS =====================

// two_vals supports two vals handling for v3 tests.
fn two_vals() (int, string) {
    return 42, 'hello'
}

// swap_ints supports swap ints handling for v3 tests.
fn swap_ints(a int, b int) (int, int) {
    return b, a
}

// three_ints supports three ints handling for v3 tests.
fn three_ints(x int) (int, int, int) {
    return x, x * 2, x * 3
}

// ===================== STRUCT OPERATORS =====================

// operator + implements the + operator for Point.
fn (a Point) + (b Point) Point {
    return Point{
        x: a.x + b.x
        y: a.y + b.y
    }
}

// operator == implements the == operator for Point.
fn (a Point) == (b Point) bool {
    return a.x == b.x && a.y == b.y
}

// operator < implements the < operator for Point.
fn (a Point) < (b Point) bool {
    return a.x + a.y < b.x + b.y
}

// ===================== RETURN MATCH / IF-EXPR-STRING =====================

// classify_str supports classify str handling for v3 tests.
fn classify_str(n int) string {
    return match n {
        0 { 'zero' }
        1 { 'one' }
        2 { 'two' }
        else { 'other' }
    }
}

// describe_sign supports describe sign handling for v3 tests.
fn describe_sign(n int) string {
    return if n > 0 {
        'positive'
    } else if n < 0 {
        'negative'
    } else {
        'zero'
    }
}

// return_assoc_point supports return assoc point handling for v3 tests.
fn return_assoc_point(p Point, new_x int) Point {
    return Point{
        ...p
        x: new_x
    }
}

// ===================== MAIN TEST FUNCTION =====================

// try_get_value supports try get value handling for v3 tests.
fn try_get_value(ok bool) ?int {
    if ok {
        return 42
    }
    return none
}

// CallInfo115 represents call info115 data used by v3 tests.
struct CallInfo115 {
    name  string
    score int
}

// maybe_call_info115 supports maybe call info115 handling for v3 tests.
fn maybe_call_info115(ok bool) ?CallInfo115 {
    if ok {
        return CallInfo115{
            name:  'resolved'
            score: 7
        }
    }
    return none
}

// make_scores115 builds make scores115 data for v3 tests.
fn make_scores115() map[string]int {
    mut scores := map[string]int{}
    scores['alpha'] = 2
    scores['beta'] = 3
    scores['gamma'] = 4
    return scores
}

// Defaults116 represents defaults116 data used by v3 tests.
struct Defaults116 {
    name  string = 'v' + '3'
    count int    = 42
}

// MetaType117 aliases meta type117 values used by v3 tests.
type MetaType117 = MetaNamed117
    | MetaIface117
    | MetaArray117
    | MetaMap117
    | MetaFn117
    | MetaPointer117

// CastLeak117 aliases cast leak117 values used by v3 tests.
type CastLeak117 = CastNamed117 | CastOther117

// SumNameLeft117 aliases sum name left117 values used by v3 tests.
type SumNameLeft117 = SumNameLeftNamed117 | SumNameLeftOther117

// SumNameRight117 aliases sum name right117 values used by v3 tests.
type SumNameRight117 = SumNameRightNamed117 | SumNameRightOther117

// MetaNamed117 represents meta named117 data used by v3 tests.
struct MetaNamed117 {
    name string
}

// MetaIface117 represents meta iface117 data used by v3 tests.
struct MetaIface117 {
    name string
}

// MetaArray117 represents meta array117 data used by v3 tests.
struct MetaArray117 {
    elem MetaType117
}

// MetaMap117 represents meta map117 data used by v3 tests.
struct MetaMap117 {
    key MetaType117
    val MetaType117
}

// MetaFn117 represents meta fn117 data used by v3 tests.
struct MetaFn117 {
    params []MetaType117
    ret    MetaType117
}

// MetaPointer117 represents meta pointer117 data used by v3 tests.
struct MetaPointer117 {
    base MetaType117
}

// Registry117 represents registry117 data used by v3 tests.
struct Registry117 {
    prefix string
mut:
    items map[string]MetaType117
}

// Stack117 represents stack117 data used by v3 tests.
struct Stack117 {
mut:
    values []int
}

// Instr117 represents instr117 data used by v3 tests.
struct Instr117 {
    op       int
    operands []int
}

// FieldBag117 represents field bag117 data used by v3 tests.
struct FieldBag117 {
    values []int
}

// TypeStore117 represents type store117 data used by v3 tests.
struct TypeStore117 {
    types []FieldBag117
}

// Symbol117 represents symbol117 data used by v3 tests.
struct Symbol117 {
    sect int
mut:
    value int
}

// SymbolStore117 represents symbol store117 data used by v3 tests.
struct SymbolStore117 {
mut:
    symbols []Symbol117
}

// ForField117 represents for field117 data used by v3 tests.
struct ForField117 {
    name string
    typ  MetaType117
}

// OptionalContext117 represents optional context117 data used by v3 tests.
struct OptionalContext117 {
    expr    string
    variant string
    sum     string
}

// OptionalContextHolder117 represents optional context holder117 data used by v3 tests.
struct OptionalContextHolder117 {
    items []OptionalContext117
}

// ConstHolder117 represents const holder117 data used by v3 tests.
struct ConstHolder117 {
    value int
}

const zero_const_holder117 = ConstHolder117{}

// CastNamed117 represents cast named117 data used by v3 tests.
struct CastNamed117 {
    name string
}

// CastOther117 represents cast other117 data used by v3 tests.
struct CastOther117 {
    id int
}

// SumNameLeftNamed117 represents sum name left named117 data used by v3 tests.
struct SumNameLeftNamed117 {
    value string
}

// SumNameLeftOther117 represents sum name left other117 data used by v3 tests.
struct SumNameLeftOther117 {}

// SumNameRightNamed117 represents sum name right named117 data used by v3 tests.
struct SumNameRightNamed117 {
    value string
}

// SumNameRightOther117 represents sum name right other117 data used by v3 tests.
struct SumNameRightOther117 {}

// Marker117 lists marker117 values used by v3 tests.
enum Marker117 {
    off
    on
}

// ScalarAlias117 aliases scalar alias117 values used by v3 tests.
type ScalarAlias117 = int

const fixed_len117 = 3

// FixedHolder117 represents fixed holder117 data used by v3 tests.
struct FixedHolder117 {
    values [fixed_len117]int
}

// FnHolder117 represents fn holder117 data used by v3 tests.
struct FnHolder117 {
    op fn (int, int) int
}

// smartcast_name117 supports smartcast name117 handling for v3 tests.
fn smartcast_name117(t CastLeak117) string {
    if t is CastNamed117 {
        return t.name
    }
    return 'other'
}

// smartcast_as_name117 converts smartcast as name117 data for v3 tests.
fn smartcast_as_name117(t CastLeak117) string {
    if t is CastNamed117 {
        named := t as CastNamed117
        return named.name
    }
    return 'other'
}

// is_on reports whether is on applies in v3 tests.
fn (t Marker117) is_on() bool {
    return t == .on
}

// qualify supports qualify handling for Registry117.
fn (r &Registry117) qualify(name string) string {
    if r.prefix.len == 0 {
        return name
    }
    return '${r.prefix}.${name}'
}

// meta_name117 supports meta name117 handling for v3 tests.
fn meta_name117(t MetaType117) string {
    if t is MetaNamed117 {
        return t.name
    }
    if t is MetaArray117 {
        return '[]' + meta_name117(t.elem)
    }
    if t is MetaMap117 {
        return 'map[' + meta_name117(t.key) + ']' + meta_name117(t.val)
    }
    if t is MetaPointer117 {
        return '&' + meta_name117(t.base)
    }
    return 'unknown'
}

// meta_array_elem117 supports meta array elem117 handling for v3 tests.
fn meta_array_elem117(t MetaType117) MetaType117 {
    if t is MetaArray117 {
        return t.elem
    }
    return MetaType117(MetaNamed117{
        name: 'none'
    })
}

// meta_fn_signature117 supports meta fn signature117 handling for v3 tests.
fn meta_fn_signature117(t MetaType117) string {
    if t is MetaFn117 {
        mut parts := []string{}
        for param117 in t.params {
            parts << meta_name117(param117)
        }
        return 'fn(${parts.join(', ')}) ${meta_name117(t.ret)}'
    }
    return 'not-fn'
}

// meta_iface_name117 supports meta iface name117 handling for v3 tests.
fn meta_iface_name117(t MetaType117) string {
    if t is MetaIface117 {
        return t.name
    }
    return 'not-interface'
}

// meta_iface_passthrough117 supports meta iface passthrough117 handling for v3 tests.
fn meta_iface_passthrough117(v MetaIface117) string {
    return v.name
}

// meta_iface_call117 supports meta iface call117 handling for v3 tests.
fn meta_iface_call117(t MetaType117) string {
    if t is MetaIface117 {
        return meta_iface_passthrough117(t)
    }
    return 'not-interface'
}

// pointer_array_elem117 supports pointer array elem117 handling for v3 tests.
fn pointer_array_elem117(t MetaType117) string {
    mut arr := MetaArray117{
        elem: MetaType117(MetaNamed117{
            name: 'none'
        })
    }
    if t is MetaPointer117 {
        ptr := t
        base := ptr.base
        if base is MetaArray117 {
            arr = base
        }
    }
    return meta_name117(arr.elem)
}

// short_variant117 supports short variant117 handling for v3 tests.
fn short_variant117(name string) string {
    mut short := name
    if name.contains('.') {
        short = name.all_after_last('.')
    }
    return short
}

// optional_match_arith117 supports optional match arith117 handling for v3 tests.
fn optional_match_arith117(op string, left int, right int) ?int {
    match op {
        'div' {
            if right == 0 {
                return none
            }
            return left / right
        }
        'mod' {
            if right == 0 {
                return none
            }
            return left % right
        }
        else {
            return none
        }
    }
}

// maybe_strings117 supports maybe strings117 handling for v3 tests.
fn maybe_strings117(ok bool) ?[]string {
    if ok {
        mut values := []string{}
        values << 'ssa'
        values << 'arm64'
        return values
    }
    return none
}

// trim_last117 transforms trim last117 data for v3 tests.
fn trim_last117(mut values []int) {
    values.delete_last()
}

// trim_stack117 transforms trim stack117 data for v3 tests.
fn trim_stack117(mut stack Stack117) {
    stack.values.delete_last()
}

// scalar_alias_if117 converts scalar alias if117 data for v3 tests.
fn scalar_alias_if117(ok bool) ScalarAlias117 {
    return if ok { ScalarAlias117(11) } else { ScalarAlias117(12) }
}

// fixed_holder_sum117 supports fixed holder sum117 handling for v3 tests.
fn fixed_holder_sum117(holder FixedHolder117) int {
    return holder.values[0] + holder.values[1] + holder.values[2]
}

// add117 supports add117 handling for v3 tests.
fn add117(a int, b int) int {
    return a + b
}

// fn_holder_call117 supports fn holder call117 handling for v3 tests.
fn fn_holder_call117(holder FnHolder117) int {
    return holder.op(4, 5)
}

// operand_total117 supports operand total117 handling for Instr117.
fn (i &Instr117) operand_total117(extra int) int {
    return i.op + i.operands[0] + extra
}

// indexed_struct_field117 supports indexed struct field117 handling for v3 tests.
fn indexed_struct_field117(store TypeStore117, idx int) int {
    bag := store.types[idx]
    if bag.values.len > 0 {
        return bag.values[0]
    }
    return -1
}

// const_holder_value117 supports const holder value117 handling for v3 tests.
fn const_holder_value117() int {
    holder := unsafe { &zero_const_holder117 }
    return holder.value
}

// adjust_symbol_values117 supports adjust symbol values117 handling for v3 tests.
fn adjust_symbol_values117(mut store SymbolStore117, base int) int {
    for i in 0 .. store.symbols.len {
        if store.symbols[i].sect == 2 {
            store.symbols[i].value += base
        }
    }
    return store.symbols[0].value + store.symbols[1].value
}

// sum_string_for_in117 supports sum string for in117 handling for v3 tests.
fn sum_string_for_in117(values []string) int {
    mut total := 0
    for value117 in values {
        total += value117.len
    }
    return total
}

// find_field_type117 resolves find field type117 information for v3 tests.
fn find_field_type117(fields []ForField117, wanted string) string {
    for field117 in fields {
        if field117.name == wanted {
            return meta_name117(field117.typ)
        }
    }
    return 'missing'
}

// map_clone_pair117 supports map clone pair117 handling for v3 tests.
fn map_clone_pair117() int {
    original117 := make_scores115()
    mut cloned117 := make_scores115()
    cloned117 = original117.clone()
    cloned117['alpha'] = 7
    orig117 := original117['alpha'] or { -1 }
    copy117 := cloned117['alpha'] or { -1 }
    return orig117 * 10 + copy117
}

// optional_context117 supports optional context117 handling for v3 tests.
fn optional_context117(holder OptionalContextHolder117, wanted string) ?OptionalContext117 {
    mut i := holder.items.len - 1
    for i >= 0 {
        if holder.items[i].expr == wanted {
            return holder.items[i]
        }
        i--
    }
    return none
}

// optional_context_score117 supports optional context score117 handling for v3 tests.
fn optional_context_score117() int {
    holder117 := OptionalContextHolder117{
        items: [
            OptionalContext117{
                expr:    'node'
                variant: 'Ident'
                sum:     'Expr'
            },
            OptionalContext117{
                expr:    'other'
                variant: 'Other'
                sum:     'Expr'
            },
        ]
    }
    ctx117 := optional_context117(holder117, 'node') or { return 0 }
    if ctx117.expr == 'node' && ctx117.variant == 'Ident' && ctx117.sum == 'Expr'
        && !ctx117.variant.contains('.') {
        return 1
    }
    return 0
}

// signed_narrow_load_score117 supports signed narrow load score117 handling for v3 tests.
fn signed_narrow_load_score117() int {
    mut values117 := []i8{}
    values117 << i8(-1)
    values117 << i8(7)
    if values117[0] < 0 && values117[1] > 0 {
        return 15
    }
    return 0
}

// push_mut_stack_selector117 updates push mut stack selector117 state for v3 tests.
fn push_mut_stack_selector117(mut stack Stack117, value int) {
    stack.values << value
}

// mut_selector_base_score117 supports mut selector base score117 handling for v3 tests.
fn mut_selector_base_score117() int {
    mut stack117 := Stack117{
        values: [3]
    }
    push_mut_stack_selector117(mut stack117, 8)
    return stack117.values[0] * 10 + stack117.values[1]
}

// chained_if_expr_score117 supports chained if expr score117 handling for v3 tests.
fn chained_if_expr_score117(value int) int {
    typ117 := if value == 0 {
        MetaType117(MetaNamed117{
            name: 'zero'
        })
    } else if value == 7 {
        MetaType117(MetaArray117{
            elem: MetaType117(MetaNamed117{
                name: 'int'
            })
        })
    } else {
        MetaType117(MetaPointer117{
            base: MetaType117(MetaNamed117{
                name: 'fallback'
            })
        })
    }
    if meta_name117(typ117) == '[]int' {
        return 80
    }
    return 0
}

// name returns name data for SumNameLeft117.
fn (t SumNameLeft117) name() string {
    if t is SumNameLeftNamed117 {
        return t.value
    }
    return 'left-other'
}

// name returns name data for SumNameRight117.
fn (t SumNameRight117) name() string {
    if t is SumNameRightNamed117 {
        return t.value
    }
    return 'right-other'
}

// sum_type_method_same_name_score117
// supports helper handling in v3 tests.
fn sum_type_method_same_name_score117() int {
    left117 := SumNameLeft117(SumNameLeftNamed117{
        value: 'left'
    })
    right117 := SumNameRight117(SumNameRightNamed117{
        value: 'right'
    })
    if left117.name() == 'left' && right117.name() == 'right' {
        return 33
    }
    return 0
}

// array_pop_score117 supports array pop score117 handling for v3 tests.
fn array_pop_score117() int {
    mut values117 := [4, 6, 9]
    last117 := values117.pop()
    return last117 * 10 + values117.len
}

// array_repeat_score117 supports array repeat score117 handling for v3 tests.
fn array_repeat_score117() int {
    base117 := []int{len: 2, init: 5}
    values117 := base117.repeat(3)
    if values117.len == 6 {
        return 6
    }
    return 0
}

// discard_assignment_side_effect_score117
// supports helper handling in v3 tests.
fn discard_assignment_side_effect_score117() int {
    g_count = 0
    _ = next_in_value()
    return g_count
}

// recursive_sum_method_score117 supports recursive sum method score117 handling for MetaType117.
fn (t MetaType117) recursive_sum_method_score117() int {
    if t is MetaPointer117 {
        if meta_name117(t.base) == 'core' {
            return 41
        }
    }
    return 0
}

// large_sumtype_method_receiver_score117 supports large_sumtype_method_receiver_score117 handling.
fn large_sumtype_method_receiver_score117() int {
    typ117 := MetaType117(MetaPointer117{
        base: MetaType117(MetaNamed117{
            name: 'core'
        })
    })
    return typ117.recursive_sum_method_score117()
}

// qualified_import_same_short_score117 supports qualified_import_same_short_score117 handling.
fn qualified_import_same_short_score117() int {
    mut score117 := repeat(`x`, 3)
    repeated117 := strings.repeat(`x`, 3)
    if repeated117.len == 3 && repeated117 == 'xxx' {
        score117 += 10
    }
    return score117
}

// sum_nine116 supports sum nine116 handling for v3 tests.
fn sum_nine116(a int, b int, c int, d int, e int, f int, g int, h int, i int) int {
    return a + b + c + d + e + f + g + h + i
}

// use_int116 supports use int116 handling for v3 tests.
fn use_int116(x int) int {
    return x
}

// BuildArch118 lists build arch118 values used by v3 tests.
enum BuildArch118 {
    amd64
    arm64
}

// callback_value118 supports callback value118 handling for v3 tests.
fn callback_value118(cb fn () int) int {
    return cb()
}

// maybe_label118 supports maybe label118 handling for v3 tests.
fn maybe_label118(ok bool) !string {
    if ok {
        return 'ok'
    }
    return error('bad')
}

// pass_error118 supports pass error118 handling for v3 tests.
fn pass_error118() !string {
    value := maybe_label118(false) or { return err }
    return value
}

// array_callback_enum_score118 supports array callback enum score118 handling for v3 tests.
fn array_callback_enum_score118() int {
    mut args118 := []string{}
    args118 << 'beta'
    args118 << '-v2'
    args118 << 'alpha'
    filtered118 := args118.filter(it != '-v2')
    mut sorted118 := filtered118.clone()
    sorted118.sort()
    mut score118 := sorted118.len * 10
    if sorted118[0] == 'alpha' && sorted118[1] == 'beta' {
        score118 += 3
    }
    if BuildArch118.arm64.str() == 'arm64' {
        score118 += 5
    }
    score118 += callback_value118(fn () int {
        return 7
    })
    _ := pass_error118() or { 'fallback' }
    return score118
}

// NestedIdent119 represents nested ident119 data used by v3 tests.
struct NestedIdent119 {
    name string
}

// NestedInfixExpr119 represents nested infix expr119 data used by v3 tests.
struct NestedInfixExpr119 {
    op string
}

// NestedMatchBranch119 represents nested match branch119 data used by v3 tests.
struct NestedMatchBranch119 {}

// NestedIfBranch119 represents nested if branch119 data used by v3 tests.
struct NestedIfBranch119 {}

// NestedExpr119 aliases nested expr119 values used by v3 tests.
type NestedExpr119 = NestedIdent119 | NestedInfixExpr119

// NestedNode119 aliases nested node119 values used by v3 tests.
type NestedNode119 = NestedExpr119 | NestedMatchBranch119 | NestedIfBranch119

// LoopHolder119 represents loop holder119 data used by v3 tests.
struct LoopHolder119 {
mut:
    current &NestedNode119 = unsafe { nil }
}

// SumPointerNilHolder119 represents sum pointer nil holder119 data used by v3 tests.
struct SumPointerNilHolder119 {
    node &NestedNode119 = unsafe { nil }
}

// SortItem119 represents sort item119 data used by v3 tests.
struct SortItem119 {
    rank int
    id   int
}

// OpVersion119 represents op version119 data used by v3 tests.
struct OpVersion119 {
    major int
}

// InterfaceField119 defines the interface field119 contract used by v3 tests.
interface InterfaceField119 {
    value int
}

// InterfaceFieldImpl119 represents interface field impl119 data used by v3 tests.
struct InterfaceFieldImpl119 {
    value int
}

// NilLink119 represents nil link119 data used by v3 tests.
struct NilLink119 {
mut:
    next &NilLink119 = unsafe { nil }
}

// IErrorDefault119 represents ierror default119 data used by v3 tests.
struct IErrorDefault119 {
    err IError = none
}

// OptionalInterp119 represents optional interp119 data used by v3 tests.
struct OptionalInterp119 {
    stop ?string
}

// MapMethodValue119 represents map method value119 data used by v3 tests.
struct MapMethodValue119 {
    kind int
}

// StaticNewLocal119 represents static new local119 data used by v3 tests.
struct StaticNewLocal119 {
    value int
}

// ZeroMapHolder119 represents zero map holder119 data used by v3 tests.
struct ZeroMapHolder119 {
mut:
    data map[string]int
}

// FeatureFlags119 lists feature flags119 values used by v3 tests.
@[flag]
enum FeatureFlags119 {
    name
    version
}

// RecursiveIf119 represents recursive if119 data used by v3 tests.
struct RecursiveIf119 {
    next &RecursiveExpr119 = unsafe { nil }
}

// RecursiveHash119 represents recursive hash119 data used by v3 tests.
struct RecursiveHash119 {
    id int
}

// HeapLocal119 represents heap local119 data used by v3 tests.
struct HeapLocal119 {
    value int
}

// SsaSumPayload119 represents ssa sum payload119 data used by v3 tests.
struct SsaSumPayload119 {
    code int
}

// FnFieldCall119 represents fn field call119 data used by v3 tests.
struct FnFieldCall119 {
    op fn (int, int) int
}

// RecursiveExpr119 aliases recursive expr119 values used by v3 tests.
type RecursiveExpr119 = RecursiveIf119 | RecursiveHash119

// RecursiveHashNode119 aliases recursive hash node119 values used by v3 tests.
type RecursiveHashNode119 = RecursiveIf119 | RecursiveHash119

// SsaSum119 aliases ssa sum119 values used by v3 tests.
type SsaSum119 = RecursiveHash119 | SsaSumPayload119

// C.atomic_fetch_add_u32 declares the C atomic_fetch_add_u32 symbol used by v3 tests.
fn C.atomic_fetch_add_u32(voidptr, u32) u32

// C.atomic_load_u16 declares the C atomic_load_u16 symbol used by v3 tests.
fn C.atomic_load_u16(voidptr) u16

// C.atomic_store_u16 declares the C atomic_store_u16 symbol used by v3 tests.
fn C.atomic_store_u16(voidptr, u16)

// C.atomic_compare_exchange_strong_u16 declares a C symbol used by v3 tests.
fn C.atomic_compare_exchange_strong_u16(voidptr, voidptr, u16) bool

// C.atomic_compare_exchange_weak_u32 declares a C symbol used by v3 tests.
fn C.atomic_compare_exchange_weak_u32(voidptr, voidptr, u32) bool

// C.atomic_compare_exchange_weak_byte declares a C symbol used by v3 tests.
fn C.atomic_compare_exchange_weak_byte(voidptr, voidptr, u8) bool

// C.atomic_compare_exchange_weak_u64 declares a C symbol used by v3 tests.
fn C.atomic_compare_exchange_weak_u64(voidptr, voidptr, u64) bool

// C.atomic_load_ptr declares the C atomic_load_ptr symbol used by v3 tests.
fn C.atomic_load_ptr(voidptr) voidptr

// C.atomic_store_ptr declares the C atomic_store_ptr symbol used by v3 tests.
fn C.atomic_store_ptr(voidptr, voidptr)

// C._wymix declares the C _wymix symbol used by v3 tests.
fn C._wymix(u64, u64) u64

// C.v_filelock_lock declares the C v_filelock_lock symbol used by v3 tests.
fn C.v_filelock_lock(i32, i32, i32, u64, u64) i32

// C.v_filelock_unlock declares the C v_filelock_unlock symbol used by v3 tests.
fn C.v_filelock_unlock(i32, u64, u64) i32

// C.v_prealloc_atomic_add_i32 declares the C v_prealloc_atomic_add_i32 symbol used by v3 tests.
fn C.v_prealloc_atomic_add_i32(voidptr, int) int

// C.v_prealloc_atomic_load_i32 declares the C v_prealloc_atomic_load_i32 symbol used by v3 tests.
fn C.v_prealloc_atomic_load_i32(voidptr) int

// C.v_prealloc_atomic_store_i32 declares the C v_prealloc_atomic_store_i32 symbol used by v3 tests.
fn C.v_prealloc_atomic_store_i32(voidptr, int) int

// C.v_prealloc_atomic_cas_i32 declares the C v_prealloc_atomic_cas_i32 symbol used by v3 tests.
fn C.v_prealloc_atomic_cas_i32(voidptr, int, int) int

// C.v_signal_with_handler_cast declares the C v_signal_with_handler_cast symbol used by v3 tests.
fn C.v_signal_with_handler_cast(i32, voidptr) voidptr

// maybe_const119 supports maybe const119 handling for v3 tests.
fn maybe_const119(ok bool) ?string {
    if ok {
        return 'set'
    }
    return none
}

const const_or119 = maybe_const119(false) or { 'fallback' }

// return_if_branch119 supports return if branch119 handling for v3 tests.
fn return_if_branch119(flag bool) int {
    return if flag { return 12 } else { 7 }
}

// match_smartcast_return119 supports match smartcast return119 handling for v3 tests.
fn match_smartcast_return119(expr NestedExpr119) string {
    ident119 := match expr {
        NestedIdent119 {
            expr as NestedIdent119
        }
        else {
            return 'not-ident'
        }
    }

    return ident119.name
}

// indexed_smartcast119 supports indexed smartcast119 handling for v3 tests.
fn indexed_smartcast119(items []NestedExpr119) string {
    first119 := items[0]
    if first119 is NestedIdent119 && first119.name == 'idx' {
        return first119.name
    }
    return 'none'
}

// nested_type_membership119 supports nested type membership119 handling for v3 tests.
fn nested_type_membership119(node NestedNode119) int {
    if node !in [NestedMatchBranch119, NestedIfBranch119, NestedInfixExpr119] {
        return 1
    }
    return 0
}

// sum_pointer_target119 supports sum pointer target119 handling for v3 tests.
fn sum_pointer_target119(node NestedNode119) int {
    mut holder119 := LoopHolder119{}
    match node {
        NestedIfBranch119 {
            holder119.current = unsafe { &node }
        }
        else {}
    }

    if isnil(holder119.current) {
        return 0
    }
    return 6
}

// compare_sort_item119 supports compare sort item119 handling for v3 tests.
fn compare_sort_item119(a &SortItem119, b &SortItem119) int {
    if a.rank < b.rank {
        return -1
    }
    if a.rank > b.rank {
        return 1
    }
    return 0
}

// sort_with_compare119 updates sort with compare119 state for v3 tests.
fn sort_with_compare119() int {
    mut items119 := [
        SortItem119{
            rank: 3
            id:   1
        },
        SortItem119{
            rank: 1
            id:   2
        },
        SortItem119{
            rank: 2
            id:   3
        },
    ]
    items119.sort_with_compare(fn (a &SortItem119, b &SortItem119) int {
        if a.rank < b.rank {
            return -1
        }
        if a.rank > b.rank {
            return 1
        }
        return 0
    })
    sorted119 := items119.sorted_with_compare(compare_sort_item119)
    return items119[0].rank * 100 + items119[1].rank * 10 + items119[2].rank + sorted119[0].id
}

// operator == implements the == operator for OpVersion119.
fn (a OpVersion119) == (b OpVersion119) bool {
    return a.major == b.major
}

// operator < implements the < operator for OpVersion119.
fn (a OpVersion119) < (b OpVersion119) bool {
    return a.major < b.major
}

// operator_compare119 supports operator compare119 handling for v3 tests.
fn operator_compare119() int {
    low119 := OpVersion119{
        major: 1
    }
    high119 := OpVersion119{
        major: 2
    }
    same119 := OpVersion119{
        major: 2
    }
    mut score119 := 0
    if high119 > low119 {
        score119 += 2
    }
    if high119 >= low119 {
        score119 += 3
    }
    if low119 <= high119 {
        score119 += 4
    }
    if high119 != low119 {
        score119 += 5
    }
    if high119 >= same119 {
        score119 += 6
    }
    if high119 <= same119 {
        score119 += 7
    }
    return score119
}

// read_interface_field119 reads read interface field119 input for v3 tests.
fn read_interface_field119(item InterfaceField119) int {
    return item.value
}

// read_interface_field_ptr119 reads read interface field ptr119 input for v3 tests.
fn read_interface_field_ptr119(item &InterfaceField119) int {
    return item.value
}

// interface_field119 supports interface field119 handling for v3 tests.
fn interface_field119() int {
    item119 := InterfaceFieldImpl119{
        value: 19
    }
    return read_interface_field119(item119) + read_interface_field_ptr119(&item119)
}

// math_generic119 supports math generic119 handling for v3 tests.
fn math_generic119() int {
    return math.abs(0 - 6) + math.min(8, 5)
}

// module_const_method119 supports module const method119 handling for v3 tests.
fn module_const_method119() int {
    return token.scanner_matcher.find('fn')
}

// qualified_static_new119 supports qualified static new119 handling for v3 tests.
fn qualified_static_new119() int {
    mut matcher119 := token.KeywordsMatcherTrie.new(2)
    matcher119.add_word('module', 71)
    return matcher119.find('module')
}

// new creates a StaticNewLocal119 value for v3 tests.
fn StaticNewLocal119.new(value int) StaticNewLocal119 {
    return StaticNewLocal119{
        value: value + 2
    }
}

// local_static_new119 supports local static new119 handling for v3 tests.
fn local_static_new119() int {
    item119 := StaticNewLocal119.new(73)
    return item119.value
}

// module_function_new119 supports module function new119 handling for v3 tests.
fn module_function_new119() int {
    mut bench119 := bench.new()
    _ = bench119
    return 101
}

// nil_newline_pointer_assignment119
// supports helper handling in v3 tests.
fn nil_newline_pointer_assignment119() int {
    mut item119 := NilLink119{}
    mut link119 := &item119.next
    unsafe {
        item119.next = nil
        *link119 = &item119
    }
    if isnil(item119.next) {
        return 0
    }
    return 21
}

// ierror_none_field119 supports ierror none field119 handling for v3 tests.
fn ierror_none_field119() int {
    default119 := IErrorDefault119{}
    explicit119 := IErrorDefault119{
        err: none
    }
    _ = default119
    _ = explicit119
    return 29
}

// sum_pointer_nil_default119 supports sum pointer nil default119 handling for v3 tests.
fn sum_pointer_nil_default119() int {
    holder119 := SumPointerNilHolder119{}
    if isnil(holder119.node) {
        return 31
    }
    return 0
}

// optional_string_interp119 supports optional string interp119 handling for v3 tests.
fn optional_string_interp119() string {
    default119 := OptionalInterp119{}
    set119 := OptionalInterp119{
        stop: 'halt'
    }
    return '${default119.stop}|${set119.stop}'
}

// optional_cast_field119 supports optional cast field119 handling for v3 tests.
fn optional_cast_field119(arg string) string {
    data119 := OptionalInterp119{
        stop: ?string(arg)
    }
    return '${data119.stop}'
}

// optional_passthrough_field119 supports optional passthrough field119 handling for v3 tests.
fn optional_passthrough_field119(default_value ?string) string {
    data119 := OptionalInterp119{
        stop: default_value
    }
    return '${data119.stop}'
}

// escape_default_string supports escape default string handling for v3 tests.
fn escape_default_string(value string) string {
    return value
}

// flag_default_value supports flag default value handling for v3 tests.
fn flag_default_value(value string) string {
    return 'not-lowered:${value}'
}

// flag_default_value_lowering119 supports flag default value lowering119 handling for v3 tests.
fn flag_default_value_lowering119() string {
    return flag_default_value('abc')
}

// query_kind119 supports query kind119 handling for map[string]MapMethodValue119.
fn (m map[string]MapMethodValue119) query_kind119(name string) ?MapMethodValue119 {
    if name in m {
        return m[name]
    }
    return none
}

// map_receiver_method119 supports map receiver method119 handling for v3 tests.
fn map_receiver_method119() int {
    mut kinds119 := map[string]MapMethodValue119{}
    kinds119['name'] = MapMethodValue119{
        kind: 41
    }
    got119 := kinds119.query_kind119('name') or { return 0 }
    return got119.kind
}

// map_index_or_none119 supports map index or none119 handling for v3 tests.
fn map_index_or_none119(items map[string]MapMethodValue119, name string) ?MapMethodValue119 {
    return items[name] or { none }
}

// map_index_bang119 supports map index bang119 handling for v3 tests.
fn map_index_bang119(items map[string]MapMethodValue119, name string) !MapMethodValue119 {
    return items[name]!
}

// map_index_optional_return119 supports map index optional return119 handling for v3 tests.
fn map_index_optional_return119() int {
    mut kinds119 := map[string]MapMethodValue119{}
    kinds119['name'] = MapMethodValue119{
        kind: 41
    }
    got119 := map_index_or_none119(kinds119, 'name') or { return 0 }
    missing119 := map_index_or_none119(kinds119, 'missing') or {
        MapMethodValue119{
            kind: 7
        }
    }
    got_bang119 := map_index_bang119(kinds119, 'name') or { return 0 }
    missing_bang119 := map_index_bang119(kinds119, 'missing') or {
        MapMethodValue119{
            kind: 5
        }
    }
    return got119.kind + missing119.kind + got_bang119.kind + missing_bang119.kind
}

// ReceiverMethodLive119 represents receiver method live119 data used by v3 tests.
struct ReceiverMethodLive119 {
    base int
}

// hidden119 supports hidden119 handling for ReceiverMethodLive119.
fn (r ReceiverMethodLive119) hidden119(extra int) int {
    return r.base + extra
}

// visible119 supports visible119 handling for ReceiverMethodLive119.
fn (r ReceiverMethodLive119) visible119(flag bool) int {
    if flag {
        return r.hidden119(64)
    }
    return r.hidden119(1)
}

// receiver_method_liveness119 supports receiver method liveness119 handling for v3 tests.
fn receiver_method_liveness119() int {
    r := ReceiverMethodLive119{
        base: 53
    }
    return r.visible119(true)
}

// zero_map_lookup119 supports zero map lookup119 handling for v3 tests.
fn zero_map_lookup119() int {
    holder119 := ZeroMapHolder119{}
    if 'missing' !in holder119.data {
        return 79
    }
    return 0
}

// flag_enum_zero119 supports flag enum zero119 handling for v3 tests.
fn flag_enum_zero119() int {
    show119 := ~FeatureFlags119.zero() ^ .name
    if show119.has(.version) && !show119.has(.name) {
        return 43
    }
    return 0
}

// sum_alias_pointer_cast119 converts sum alias pointer cast119 data for v3 tests.
fn sum_alias_pointer_cast119(expr RecursiveExpr119) int {
    alias119 := &RecursiveHashNode119(expr as RecursiveIf119)
    if isnil(alias119) {
        return 0
    }
    return 9
}

// at_location119 supports at location119 handling for v3 tests.
fn at_location119() int {
    location119 := @LOCATION
    if location119.len > 0 {
        return 4
    }
    return 0
}

// c_atomic_wymix119 supports c atomic wymix119 handling for v3 tests.
fn c_atomic_wymix119() int {
    mut counter119 := u32(4)
    old119 := C.atomic_fetch_add_u32(voidptr(&counter119), u32(3))
    mix119 := C._wymix(u64(11), u64(17))
    mut score119 := int(old119) + int(counter119)
    if mix119 != 0 {
        score119 += 2
    }
    return score119
}

// c_atomic_channel_helpers119 supports c atomic channel helpers119 handling for v3 tests.
fn c_atomic_channel_helpers119() int {
    mut score119 := 0
    mut flag119 := u16(0)
    mut expected16_119 := u16(0)
    if C.atomic_compare_exchange_strong_u16(voidptr(&flag119), voidptr(&expected16_119), u16(3)) {
        score119 += int(C.atomic_load_u16(voidptr(&flag119)))
    }
    C.atomic_store_u16(voidptr(&flag119), u16(4))
    score119 += int(C.atomic_load_u16(voidptr(&flag119)))
    mut counter119 := u32(2)
    mut expected32_119 := u32(2)
    if C.atomic_compare_exchange_weak_u32(voidptr(&counter119), voidptr(&expected32_119), u32(5)) {
        score119 += int(counter119)
    }
    mut locked119 := u8(0)
    mut expected_byte119 := u8(0)
    if C.atomic_compare_exchange_weak_byte(voidptr(&locked119), voidptr(&expected_byte119), u8(8)) {
        score119 += int(locked119)
    }
    mut big119 := u64(10)
    mut expected64_119 := u64(10)
    if C.atomic_compare_exchange_weak_u64(voidptr(&big119), voidptr(&expected64_119), u64(12)) {
        score119 += int(big119)
    }
    value119 := 9
    mut slot119 := unsafe { nil }
    C.atomic_store_ptr(voidptr(&slot119), voidptr(&value119))
    if C.atomic_load_ptr(voidptr(&slot119)) == voidptr(&value119) {
        score119 += 6
    }
    return score119
}

// c_filelock_helpers119 supports c filelock helpers119 handling for v3 tests.
fn c_filelock_helpers119() int {
    lock_result119 := C.v_filelock_lock(i32(-1), 1, 1, u64(0), u64(0))
    unlock_result119 := C.v_filelock_unlock(i32(-1), u64(0), u64(0))
    if lock_result119 != 0 && unlock_result119 != 0 {
        return 47
    }
    return 0
}

// local_address_return119 supports local address return119 handling for v3 tests.
fn local_address_return119() &HeapLocal119 {
    item119 := HeapLocal119{
        value: 53
    }
    return &item119
}

// heap_local_return119 supports heap local return119 handling for v3 tests.
fn heap_local_return119() int {
    item119 := local_address_return119()
    return item119.value
}

// rune_array_string119 supports rune array string119 handling for v3 tests.
fn rune_array_string119() int {
    runes119 := [rune(`v`), rune(`3`)]
    if runes119.string() == 'v3' {
        return 61
    }
    return 0
}

// prealloc_atomic_helpers119 supports prealloc atomic helpers119 handling for v3 tests.
fn prealloc_atomic_helpers119() int {
    mut value119 := 1
    C.v_prealloc_atomic_store_i32(voidptr(&value119), 2)
    mut score119 := value119
    score119 += C.v_prealloc_atomic_load_i32(voidptr(&value119))
    score119 += C.v_prealloc_atomic_add_i32(voidptr(&value119), 3)
    if C.v_prealloc_atomic_cas_i32(voidptr(&value119), 5, 7) != 0 {
        score119 += value119
    }
    return score119
}

// signal_handler_cast119 supports signal handler cast119 handling for v3 tests.
fn signal_handler_cast119() int {
    prev119 := C.v_signal_with_handler_cast(0, unsafe { nil })
    if isnil(prev119) {
        return 67
    }
    return 67
}

// printing_builtin_helpers119 supports printing builtin helpers119 handling for v3 tests.
fn printing_builtin_helpers119() int {
    print('')
    eprint('')
    eprintln('')
    return 89
}

// string_last_part_helpers119 supports string last part helpers119 handling for v3 tests.
fn string_last_part_helpers119() int {
    path119 := 'vlib/v3/v3.v'
    if path119.all_before_last('/') == 'vlib/v3' && path119.all_after_last('/') == 'v3.v' {
        return 97
    }
    return 0
}

// join_path_variadic119 supports join path variadic119 handling for v3 tests.
fn join_path_variadic119() int {
    sep119 := os.path_separator
    expected119 := 'vlib' + sep119 + 'v3' + sep119 + 'v3.v'
    path119 := os.join_path('vlib', 'v3', 'v3.v')
    if path119 == expected119 {
        return 107
    }
    return 0
}

// ssa_sum_payload_store119 supports ssa sum payload store119 handling for v3 tests.
fn ssa_sum_payload_store119() int {
    payload119 := SsaSum119(SsaSumPayload119{
        code: 109
    })
    if payload119 is SsaSumPayload119 {
        return payload119.code
    }
    return 0
}

// add_fn_field119 updates add fn field119 state for v3 tests.
fn add_fn_field119(a int, b int) int {
    return a + b
}

// make_fn_field119 builds make fn field119 data for v3 tests.
fn make_fn_field119() FnFieldCall119 {
    return FnFieldCall119{
        op: add_fn_field119
    }
}

// selector_fn_call_base119 supports selector fn call base119 handling for v3 tests.
fn selector_fn_call_base119() int {
    return make_fn_field119().op(50, 63)
}

// channel_runtime119 supports channel runtime119 handling for v3 tests.
fn channel_runtime119() int {
    mutex119 := sync.new_mutex()
    _ = mutex119
    ch119 := chan bool{cap: 1}
    ch119 <- true
    got119 := <-ch119
    ch119.close()
    mut score119 := 0
    if got119 {
        score119 += 17
    }
    if ch119.closed {
        score119 += 19
    }
    waiters119 := [ch119]
    if waiters119[0] == ch119 {
        score119 += 23
    }
    return score119
}

// ZeroDefaultStruct119 represents zero default struct119 data used by v3 tests.
struct ZeroDefaultStruct119 {
    name    string
    count   int
    enabled bool
}

// zero_default_struct119 supports zero default struct119 handling for v3 tests.
fn zero_default_struct119() int {
    item119 := ZeroDefaultStruct119{}
    if item119.name == '' && item119.count == 0 && !item119.enabled {
        return 103
    }
    return 0
}

// main runs the v3 tests entry point.
fn main() {
    print_str('=== v3 Test Suite ===')

    // ==================== 1. STRUCT DECL & INIT (5 tests) ====================
    print_str('--- 1. Struct Declaration & Initialization ---')

    // 1.1 Basic struct init
    p1 := Point{
        x: 10
        y: 20
    }
    print_int(p1.x) // 10
    print_int(p1.y) // 20

    // 1.2 Default zero init
    p2 := Point{}
    print_int(p2.x) // 0
    print_int(p2.y) // 0

    // 1.3 Mutable struct modification
    mut p3 := Point{
        x: 1
        y: 2
    }
    p3.x = 100
    p3.y = 200
    print_int(p3.x) // 100
    print_int(p3.y) // 200

    // 1.4 Struct with computed values
    base := 7
    p4 := Point{
        x: base * 2
        y: base * 3
    }
    print_int(p4.x) // 14
    print_int(p4.y) // 21

    // 1.5 Multiple struct instances
    p5a := Point{
        x: 1
        y: 2
    }
    p5b := Point{
        x: 3
        y: 4
    }
    print_int(p5a.x + p5b.x) // 4
    print_int(p5a.y + p5b.y) // 6

    // ==================== 2. CALLS & SELECTOR ASSIGN (5 tests) ====================
    print_str('--- 2. Calls & Selector Assignment ---')

    // 2.1 Basic function call with selector assign
    mut pt := Point{
        x: 10
        y: 20
    }
    pt.x = add(pt.x, 5)
    print_int(pt.x) // 15

    // 2.2 Chained calls
    pt.y = add(add(pt.y, 10), 5)
    print_int(pt.y) // 35

    // 2.3 Call result to selector with subtraction
    pt.x = sub(pt.x, 3)
    print_int(pt.x) // 12

    // 2.4 Multiple selectors updated via calls
    mut pt2 := Point{
        x: 5
        y: 5
    }
    pt2.x = mul(pt2.x, 3)
    pt2.y = mul(pt2.y, 4)
    print_int(pt2.x) // 15
    print_int(pt2.y) // 20

    // 2.5 Nested function calls with selectors
    mut pt3 := Point{
        x: 10
        y: 20
    }
    pt3.x = add(mul(pt3.x, 2), 5) // 10*2 + 5 = 25
    pt3.y = sub(mul(pt3.y, 3), 10) // 20*3 - 10 = 50
    print_int(pt3.x) // 25
    print_int(pt3.y) // 50

    // ==================== 3. GLOBALS & COMPOUND ASSIGN (5 tests) ====================
    print_str('--- 3. Globals & Compound Assignment ---')

    // 3.1 Basic global assignment and compound add
    g_val = 50
    g_val += 50
    print_int(g_val) // 100

    // 3.2 Compound subtract
    g_val = 100
    g_val -= 30
    print_int(g_val) // 70

    // 3.3 Compound multiply
    g_val = 5
    g_val *= 6
    print_int(g_val) // 30

    // 3.4 Compound divide
    g_val = 100
    g_val /= 4
    print_int(g_val) // 25

    // 3.5 Global struct
    g_point.x = 42
    g_point.y = 84
    g_point.x += 8
    print_int(g_point.x) // 50
    print_int(g_point.y) // 84

    // ==================== 4. BOOL & LOGIC (5 tests) ====================
    print_str('--- 4. Bool & Logic ---')

    // 4.1 Basic bool true
    flag1 := true
    if flag1 {
        print_int(1)
    } else {
        print_int(0)
    }

    // 4.2 Basic bool false
    flag2 := false
    if flag2 {
        print_int(1)
    } else {
        print_int(0)
    }

    // 4.3 Bool from comparison
    cmp_val := 10
    flag3 := cmp_val > 5
    if flag3 {
        print_int(1)
    } else {
        print_int(0)
    }

    // 4.4 Logical AND
    a_bool := true
    b_bool := true
    if a_bool && b_bool {
        print_int(1)
    } else {
        print_int(0)
    }

    // 4.5 Logical OR and NOT
    c_bool := false
    d_bool := true
    if c_bool || d_bool {
        print_int(1) // 1
    } else {
        print_int(0)
    }
    if !c_bool {
        print_int(1) // 1
    } else {
        print_int(0)
    }

    // ==================== 5. LOOP WITH BREAK/CONTINUE (5 tests) ====================
    print_str('--- 5. Loop with Break/Continue ---')

    // 5.1 Basic continue (skip 5)
    mut sum1 := 0
    mut i1 := 0
    for i1 < 10 {
        i1++
        if i1 == 5 {
            continue
        }
        if i1 > 7 {
            break
        }
        sum1 += i1
    }
    print_int(sum1) // 1+2+3+4+6+7 = 23

    // 5.2 Multiple continues (skip even)
    mut sum2 := 0
    mut i2 := 0
    for i2 < 10 {
        i2++
        if i2 % 2 == 0 {
            continue
        }
        sum2 += i2
    }
    print_int(sum2) // 1+3+5+7+9 = 25

    // 5.3 Early break
    mut sum3 := 0
    mut i3 := 0
    for i3 < 100 {
        i3++
        if i3 > 5 {
            break
        }
        sum3 += i3
    }
    print_int(sum3) // 1+2+3+4+5 = 15

    // 5.4 Combined break and continue
    mut sum4 := 0
    mut i4 := 0
    for i4 < 20 {
        i4++
        if i4 % 3 == 0 {
            continue
        }
        if i4 > 10 {
            break
        }
        sum4 += i4
    }
    print_int(sum4) // 1+2+4+5+7+8+10 = 37

    // 5.5 Simple condition loop
    mut sum5 := 0
    mut i5 := 0
    for i5 < 5 {
        sum5 += i5
        i5++
    }
    print_int(sum5) // 0+1+2+3+4 = 10

    // ==================== 6. MATCH (5 tests) ====================
    print_str('--- 6. Match ---')

    // 6.1 Match with else
    x1 := 10
    match x1 {
        1 { print_int(1) }
        2 { print_int(2) }
        else { print_int(777) }
    }

    // 6.2 Match exact case
    x2 := 2
    match x2 {
        1 { print_int(100) }
        2 { print_int(200) }
        3 { print_int(300) }
        else { print_int(0) }
    }

    // 6.3 Match first case
    x3 := 1
    match x3 {
        1 { print_int(111) }
        2 { print_int(222) }
        else { print_int(999) }
    }

    // 6.4 Match with computation
    x4 := 5
    match x4 {
        1 { print_int(x4 * 10) }
        5 { print_int(x4 * 100) }
        else { print_int(0) }
    }

    // 6.5 Match with more cases
    x5 := 4
    match x5 {
        1 { print_int(10) }
        2 { print_int(20) }
        3 { print_int(30) }
        4 { print_int(40) }
        5 { print_int(50) }
        else { print_int(0) }
    }

    // ==================== 7. C-STYLE LOOP & FACTORIAL (5 tests) ====================
    print_str('--- 7. C-style Loop ---')

    // 7.1 Basic factorial
    mut fact1 := 1
    for k := 1; k <= 5; k++ {
        fact1 = fact1 * k
    }
    print_int(fact1) // 120

    // 7.2 Sum 1 to 10
    mut sum7 := 0
    for k := 1; k <= 10; k++ {
        sum7 += k
    }
    print_int(sum7) // 55

    // 7.3 Powers of 2
    mut pow2 := 1
    for k := 0; k < 8; k++ {
        pow2 = pow2 * 2
    }
    print_int(pow2) // 256

    // 7.4 Countdown
    mut countdown := 0
    for k := 10; k > 0; k-- {
        countdown += k
    }
    print_int(countdown) // 55

    // 7.5 Step by 2
    mut sum_even := 0
    for k := 0; k <= 10; k += 2 {
        sum_even += k
    }
    print_int(sum_even) // 0+2+4+6+8+10 = 30

    // ==================== 8. RECURSIVE FUNCTIONS (5 tests) ====================
    print_str('--- 8. Recursive Functions ---')

    // 8.1 Fibonacci
    print_int(fib(10)) // 55

    // 8.2 Factorial recursive
    print_int(factorial(6)) // 720

    // 8.3 Sum recursive
    print_int(sum_recursive(10)) // 55

    // 8.4 GCD
    print_int(gcd(48, 18)) // 6

    // 8.5 Power
    print_int(power(2, 10)) // 1024

    // ==================== 9. NESTED LOOPS (5 tests) ====================
    print_str('--- 9. Nested Loops ---')

    // 9.1 Basic 3x3
    mut count1 := 0
    mut r1 := 0
    for r1 < 3 {
        mut c1 := 0
        for c1 < 3 {
            count1++
            c1++
        }
        r1++
    }
    print_int(count1) // 9

    // 9.2 4x5 grid
    mut count2 := 0
    mut r2 := 0
    for r2 < 4 {
        mut c2 := 0
        for c2 < 5 {
            count2++
            c2++
        }
        r2++
    }
    print_int(count2) // 20

    // 9.3 Sum of products
    mut sum9 := 0
    mut r3 := 1
    for r3 <= 3 {
        mut c3 := 1
        for c3 <= 3 {
            sum9 += r3 * c3
            c3++
        }
        r3++
    }
    print_int(sum9) // (1+2+3) + (2+4+6) + (3+6+9) = 36

    // 9.4 2x3 with accumulator
    mut count4 := 0
    mut r4 := 0
    for r4 < 2 {
        mut c4 := 0
        for c4 < 3 {
            count4 += 1
            c4++
        }
        r4++
    }
    print_int(count4) // 6

    // 9.5 Inner break
    mut count5 := 0
    mut r5 := 0
    for r5 < 5 {
        mut c5 := 0
        for c5 < 10 {
            if c5 >= 3 {
                break
            }
            count5++
            c5++
        }
        r5++
    }
    print_int(count5) // 5*3 = 15

    // ==================== 10. INFINITE LOOP (5 tests) ====================
    print_str('--- 10. Infinite Loop ---')

    // 10.1 Basic infinite with break
    mut iter1 := 0
    for {
        iter1++
        if iter1 == 5 {
            break
        }
    }
    print_int(iter1) // 5

    // 10.2 Sum until threshold
    mut sum10 := 0
    mut n10 := 0
    for {
        n10++
        sum10 += n10
        if sum10 > 20 {
            break
        }
    }
    print_int(sum10) // 21 (1+2+3+4+5+6 = 21)

    // 10.3 Find first power of 2 > 100
    mut pow := 1
    for {
        pow = pow * 2
        if pow > 100 {
            break
        }
    }
    print_int(pow) // 128

    // 10.4 Countdown in infinite loop
    mut cd := 10
    for {
        cd--
        if cd == 0 {
            break
        }
    }
    print_int(cd) // 0

    // 10.5 Simple counter
    mut x10 := 0
    for {
        x10++
        if x10 >= 10 {
            break
        }
    }
    print_int(x10) // 10

    // ==================== 11. MANY ARGUMENTS (5 tests) ====================
    print_str('--- 11. Many Arguments ---')

    // 11.1 Sum of 8 ones
    print_int(sum_many(1, 1, 1, 1, 1, 1, 1, 1)) // 8

    // 11.2 Sum of sequence
    print_int(sum_many(1, 2, 3, 4, 5, 6, 7, 8)) // 36

    // 11.3 Product of small numbers
    print_int(mul_many(1, 2, 1, 2, 1, 2, 1, 2)) // 16

    // 11.4 Max of 8
    print_int(max_of_eight(3, 7, 2, 9, 1, 8, 4, 6)) // 9

    // 11.5 Weighted sum
    print_int(weighted_sum(1, 1, 1, 1, 1, 1, 1, 1)) // 1+2+3+4+5+6+7+8 = 36

    // ==================== 12. MODIFYING STRUCT (5 tests) ====================
    print_str('--- 12. Modifying Struct via Function ---')

    // 12.1 Basic modify
    mut pm1 := Point{
        x: 10
        y: 20
    }
    modify_struct(mut pm1)
    print_int(pm1.x) // 999
    print_int(pm1.y) // 888

    // 12.2 Swap
    mut pm2 := Point{
        x: 5
        y: 15
    }
    swap_point(mut pm2)
    print_int(pm2.x) // 15
    print_int(pm2.y) // 5

    // 12.3 Scale
    mut pm3 := Point{
        x: 10
        y: 20
    }
    scale_point(mut pm3, 3)
    print_int(pm3.x) // 30
    print_int(pm3.y) // 60

    // 12.4 Translate
    mut pm4 := Point{
        x: 5
        y: 10
    }
    translate_point(mut pm4, 100, 200)
    print_int(pm4.x) // 105
    print_int(pm4.y) // 210

    // 12.5 Reset
    mut pm5 := Point{
        x: 999
        y: 888
    }
    reset_point(mut pm5)
    print_int(pm5.x) // 0
    print_int(pm5.y) // 0

    // ==================== 13. ASSERT (5 tests) ====================
    print_str('--- 13. Assert ---')

    // 13.1 Basic equality
    assert 1 == 1
    print_str('Assert 1 passed')

    // 13.2 Computed equality
    assert 2 + 2 == 4
    print_str('Assert 2 passed')

    // 13.3 Boolean assert
    assert true
    print_str('Assert 3 passed')

    // 13.4 Comparison assert
    assert 10 > 5
    print_str('Assert 4 passed')

    // 13.5 Complex expression
    assert (3 * 4) == (2 * 6)
    print_str('Assert 5 passed')

    // ==================== 14. HEAP ALLOCATION (5 tests) ====================
    print_str('--- 14. Heap Allocation ---')

    // 14.1 Basic heap Point
    hp1 := &Point{
        x: 10
        y: 20
    }
    print_int(hp1.x) // 10
    print_int(hp1.y) // 20

    // 14.2 Heap with zero
    hp2 := &Point{
        x: 0
        y: 0
    }
    print_int(hp2.x) // 0
    print_int(hp2.y) // 0

    // 14.3 Heap with computed values
    hp3 := &Point{
        x: 5 * 5
        y: 6 * 6
    }
    print_int(hp3.x) // 25
    print_int(hp3.y) // 36

    // 14.4 Heap Rectangle
    hr := &Rectangle{
        width:  100
        height: 200
        origin: Point{
            x: 10
            y: 20
        }
    }
    print_int(hr.width) // 100
    print_int(hr.height) // 200

    // 14.5 Heap Node
    hn := &Node{
        value: 42
        left:  1
        right: 2
    }
    print_int(hn.value) // 42
    print_int(hn.left) // 1
    print_int(hn.right) // 2

    // ==================== 15. BITWISE OPERATIONS (5 tests) ====================
    print_str('--- 15. Bitwise Operations ---')

    // 15.1 Basic AND
    print_int(0b1100 & 0b1010) // 8

    // 15.2 Basic OR
    print_int(0b1100 | 0b1010) // 14

    // 15.3 Basic XOR
    print_int(0b1100 ^ 0b1010) // 6

    // 15.4 Mask extraction
    num := 0xABCD
    low_byte := num & 0xFF
    print_int(low_byte) // 0xCD = 205

    // 15.5 Bit set/clear
    mut flags := 0
    flags = flags | 0b0001 // set bit 0
    flags = flags | 0b0100 // set bit 2
    print_int(flags) // 5
    flags = flags & 0b1110 // clear bit 0
    print_int(flags) // 4

    // ==================== 16. SHIFT OPERATIONS (5 tests) ====================
    print_str('--- 16. Shift Operations ---')

    // 16.1 Left shift basic
    print_int(1 << 4) // 16

    // 16.2 Right shift basic
    print_int(32 >> 2) // 8

    // 16.3 Multiple shifts
    print_int(255 >> 4) // 15

    // 16.4 Shift for multiply
    val16 := 7
    print_int(val16 << 3) // 7 * 8 = 56

    // 16.5 Shift for divide
    val17 := 96
    print_int(val17 >> 4) // 96 / 16 = 6

    // ==================== 17. MODULO (5 tests) ====================
    print_str('--- 17. Modulo ---')

    // 17.1 Basic modulo
    print_int(17 % 5) // 2

    // 17.2 Modulo with larger divisor
    print_int(100 % 7) // 2

    // 17.3 Even/odd check
    print_int(15 % 2) // 1 (odd)
    print_int(16 % 2) // 0 (even)

    // 17.4 Clock arithmetic
    hour := 23
    new_hour := (hour + 5) % 24
    print_int(new_hour) // 4

    // 17.5 Digit extraction
    num17 := 12345
    last_digit := num17 % 10
    print_int(last_digit) // 5
    second_digit := (num17 / 10) % 10
    print_int(second_digit) // 4

    // ==================== 18. POINTER ARITHMETIC (5 tests) ====================
    print_str('--- 18. Pointer Arithmetic ---')

    // 18.1 Heap struct access
    hp_arr1 := &Point{
        x: 10
        y: 20
    }
    print_int(hp_arr1.x) // 10
    print_int(hp_arr1.y) // 20

    // 18.2 Multiple heap structs
    hp_arr2 := &Point{
        x: 100
        y: 200
    }
    hp_arr3 := &Point{
        x: 300
        y: 400
    }
    print_int(hp_arr2.x + hp_arr3.x) // 400
    print_int(hp_arr2.y + hp_arr3.y) // 600

    // 18.3 Heap struct with computed values
    base18 := 5
    hp_arr4 := &Point{
        x: base18 * 10
        y: base18 * 20
    }
    print_int(hp_arr4.x) // 50
    print_int(hp_arr4.y) // 100

    // 18.4 Multiple heap allocations in loop
    mut sum18 := 0
    mut i18 := 0
    for i18 < 3 {
        hp := &Point{
            x: i18 * 10
            y: i18 * 20
        }
        sum18 = sum18 + hp.x + hp.y
        i18++
    }
    print_int(sum18) // 0+0 + 10+20 + 20+40 = 90

    // 18.5 Heap node tree structure
    node1 := &Node{
        value: 100
        left:  0
        right: 0
    }
    node2 := &Node{
        value: 200
        left:  0
        right: 0
    }
    print_int(node1.value + node2.value) // 300

    // ==================== 19. NESTED STRUCT ACCESS (5 tests) ====================
    print_str('--- 19. Nested Struct Access ---')

    // 19.1 Basic nested access
    rect := Rectangle{
        width:  100
        height: 200
        origin: Point{
            x: 10
            y: 20
        }
    }
    print_int(rect.width) // 100
    print_int(rect.height) // 200

    // 19.2 Nested struct field via intermediate
    rect2 := Rectangle{
        width:  50
        height: 60
        origin: Point{
            x: 5
            y: 6
        }
    }
    print_int(rect2.width + rect2.height) // 110

    // 19.3 Mutable nested struct modification
    mut rect3 := Rectangle{
        width:  10
        height: 20
        origin: Point{
            x: 1
            y: 2
        }
    }
    rect3.width = 100
    rect3.height = 200
    print_int(rect3.width) // 100
    print_int(rect3.height) // 200

    // 19.4 Multiple rectangles
    rect4a := Rectangle{
        width:  10
        height: 20
        origin: Point{
            x: 0
            y: 0
        }
    }
    rect4b := Rectangle{
        width:  30
        height: 40
        origin: Point{
            x: 0
            y: 0
        }
    }
    print_int(rect4a.width + rect4b.width) // 40
    print_int(rect4a.height + rect4b.height) // 60

    // 19.5 Rectangle area
    rect5 := Rectangle{
        width:  12
        height: 10
        origin: Point{
            x: 0
            y: 0
        }
    }
    area := rect5.width * rect5.height
    print_int(area) // 120

    // ==================== 20. NEGATIVE NUMBERS (5 tests) ====================
    print_str('--- 20. Negative Numbers ---')

    // 20.1 Unary minus
    n1 := 0 - 42
    print_int(n1) // -42

    // 20.2 Negative addition
    n2 := 0 - 10
    n3 := n2 + 5
    print_int(n3) // -5

    // 20.3 Negative subtraction
    n4 := 0 - 20
    n5 := n4 - 10
    print_int(n5) // -30

    // 20.4 Negative multiplication
    n6 := 0 - 7
    n7 := n6 * 3
    print_int(n7) // -21

    // 20.5 Double negative (positive)
    n8 := 0 - 50
    n9 := 0 - n8
    print_int(n9) // 50

    // ==================== 21. ELSE-IF CHAINS (5 tests) ====================
    print_str('--- 21. Else-If Chains ---')

    // 21.1 classify function (> 100)
    print_int(classify(200)) // 3

    // 21.2 classify (> 50)
    print_int(classify(75)) // 2

    // 21.3 classify (> 0)
    print_int(classify(25)) // 1

    // 21.4 classify (<= 0)
    print_int(classify(0)) // 0

    // 21.5 Multiple else-if inline
    val21 := 42
    mut r21 := 0
    if val21 > 100 {
        r21 = 5
    } else if val21 > 50 {
        r21 = 4
    } else if val21 > 40 {
        r21 = 3
    } else if val21 > 30 {
        r21 = 2
    } else {
        r21 = 1
    }
    print_int(r21) // 3

    // ==================== 22. FUNCTION RETURNING STRUCT (5 tests) ====================
    print_str('--- 22. Function Returning Struct ---')

    // 22.1 Basic make_point
    rp1 := make_point(10, 20)
    print_int(rp1.x) // 10
    print_int(rp1.y) // 20

    // 22.2 make_point with computation
    rp2 := make_point(3 * 5, 4 * 6)
    print_int(rp2.x) // 15
    print_int(rp2.y) // 24

    // 22.3 add_points
    rp3 := add_points(Point{ x: 10, y: 20 }, Point{
        x: 30
        y: 40
    })
    print_int(rp3.x) // 40
    print_int(rp3.y) // 60

    // 22.4 Chained struct returns
    rp4 := add_points(make_point(1, 2), make_point(3, 4))
    print_int(rp4.x) // 4
    print_int(rp4.y) // 6

    // 22.5 Return struct used in arithmetic
    rp5 := make_point(100, 200)
    print_int(rp5.x + rp5.y) // 300

    // ==================== 23. EARLY RETURN (5 tests) ====================
    print_str('--- 23. Early Return ---')

    // 23.1 abs positive
    print_int(abs_val(42)) // 42

    // 23.2 abs negative
    print_int(abs_val(0 - 17)) // 17

    // 23.3 abs zero
    print_int(abs_val(0)) // 0

    // 23.4 min
    print_int(min_val(10, 20)) // 10

    // 23.5 max
    print_int(max_val(10, 20)) // 20

    // ==================== 24. CLAMP & MULTI-ARG FUNCTIONS (5 tests) ====================
    print_str('--- 24. Clamp & Multi-Arg Functions ---')

    // 24.1 clamp below
    print_int(clamp(5, 10, 100)) // 10

    // 24.2 clamp above
    print_int(clamp(200, 10, 100)) // 100

    // 24.3 clamp in range
    print_int(clamp(50, 10, 100)) // 50

    // 24.4 clamp at boundary
    print_int(clamp(10, 10, 100)) // 10

    // 24.5 clamp at upper boundary
    print_int(clamp(100, 10, 100)) // 100

    // ==================== 25. POSTFIX INC/DEC (5 tests) ====================
    print_str('--- 25. Postfix Inc/Dec ---')

    // 25.1 Basic increment
    mut pi1 := 10
    pi1++
    print_int(pi1) // 11

    // 25.2 Basic decrement
    mut pd1 := 10
    pd1--
    print_int(pd1) // 9

    // 25.3 Multiple increments
    mut pi2 := 0
    pi2++
    pi2++
    pi2++
    pi2++
    pi2++
    print_int(pi2) // 5

    // 25.4 Inc and dec combined
    mut pid := 100
    pid++
    pid++
    pid--
    print_int(pid) // 101

    // 25.5 Postfix in loop
    mut pi3 := 0
    mut cnt25 := 0
    for pi3 < 10 {
        pi3++
        cnt25++
    }
    print_int(cnt25) // 10

    // ==================== 26. COMPOUND BITWISE ASSIGNMENT (5 tests) ====================
    print_str('--- 26. Compound Bitwise Assignment ---')

    // 26.1 OR assign
    mut bw1 := 0b0011
    bw1 |= 0b1100
    print_int(bw1) // 15

    // 26.2 AND assign
    mut bw2 := 0b1111
    bw2 &= 0b1010
    print_int(bw2) // 10

    // 26.3 XOR assign
    mut bw3 := 0b1100
    bw3 ^= 0b1010
    print_int(bw3) // 6

    // 26.4 Shift left assign
    mut bw4 := 1
    bw4 <<= 4
    print_int(bw4) // 16

    // 26.5 Shift right assign
    mut bw5 := 128
    bw5 >>= 3
    print_int(bw5) // 16

    // ==================== 27. COMPLEX BOOLEAN (5 tests) ====================
    print_str('--- 27. Complex Boolean ---')

    // 27.1 AND chain
    if 10 > 5 && 20 > 10 && 30 > 20 {
        print_int(1)
    } else {
        print_int(0)
    }

    // 27.2 OR chain
    if false || false || true {
        print_int(1)
    } else {
        print_int(0)
    }

    // 27.3 Mixed AND/OR
    if (true && false) || (true && true) {
        print_int(1)
    } else {
        print_int(0)
    }

    // 27.4 NOT with AND
    if !false && !false {
        print_int(1)
    } else {
        print_int(0)
    }

    // 27.5 Complex condition
    v27 := 42
    if v27 > 10 && v27 < 100 && v27 % 2 == 0 {
        print_int(1)
    } else {
        print_int(0)
    }

    // ==================== 28. ITERATIVE ALGORITHMS (5 tests) ====================
    print_str('--- 28. Iterative Algorithms ---')

    // 28.1 Collatz for 6 (6->3->10->5->16->8->4->2->1 = 8 steps)
    print_int(collatz_steps(6)) // 8

    // 28.2 Collatz for 27 (111 steps)
    print_int(collatz_steps(27)) // 111

    // 28.3 Collatz for 1 (0 steps)
    print_int(collatz_steps(1)) // 0

    // 28.4 Sum digits
    print_int(sum_digits(12345)) // 15

    // 28.5 Sum digits of large number
    print_int(sum_digits(99999)) // 45

    // ==================== 29. BIT COUNTING (5 tests) ====================
    print_str('--- 29. Bit Counting ---')

    // 29.1 count_bits of 0
    print_int(count_bits(0)) // 0

    // 29.2 count_bits of 7 (111)
    print_int(count_bits(7)) // 3

    // 29.3 count_bits of 255 (11111111)
    print_int(count_bits(255)) // 8

    // 29.4 count_bits of 1024 (10000000000)
    print_int(count_bits(1024)) // 1

    // 29.5 count_bits of 0b10101010
    print_int(count_bits(0b10101010)) // 4

    // ==================== 30. GLOBAL COUNTER PATTERNS (5 tests) ====================
    print_str('--- 30. Global Counter Patterns ---')

    // 30.1 Global counter in loop
    g_count = 0
    mut ig := 0
    for ig < 10 {
        g_count += ig
        ig++
    }
    print_int(g_count) // 45

    // 30.2 Global flag
    g_flag = false
    if g_count > 40 {
        g_flag = true
    }
    if g_flag {
        print_int(1)
    } else {
        print_int(0)
    }

    // 30.3 Global struct modification in loop
    g_point.x = 0
    g_point.y = 0
    mut ig2 := 1
    for ig2 <= 5 {
        g_point.x += ig2
        g_point.y += ig2 * ig2
        ig2++
    }
    print_int(g_point.x) // 15
    print_int(g_point.y) // 55

    // 30.4 Global with compound multiply
    g_val = 1
    mut ig3 := 1
    for ig3 <= 5 {
        g_val *= ig3
        ig3++
    }
    print_int(g_val) // 120

    // 30.5 Global reset and reuse
    g_val = 999
    g_val = 0
    g_val += 42
    print_int(g_val) // 42

    // ==================== 31. NESTED STRUCT MUTATION (5 tests) ====================
    print_str('--- 31. Nested Struct Mutation ---')

    // 31.1 Modify nested struct width/height
    mut rm1 := Rectangle{
        width:  10
        height: 20
        origin: Point{
            x: 1
            y: 2
        }
    }
    rm1.width = 50
    rm1.height = 60
    print_int(rm1.width) // 50
    print_int(rm1.height) // 60

    // 31.2 Scale rectangle via function
    mut rm2 := Rectangle{
        width:  10
        height: 20
        origin: Point{
            x: 0
            y: 0
        }
    }
    scale_rect(mut rm2, 5)
    print_int(rm2.width) // 50
    print_int(rm2.height) // 100

    // 31.3 Multiple rectangle modifications
    mut rm3 := Rectangle{
        width:  5
        height: 5
        origin: Point{
            x: 0
            y: 0
        }
    }
    rm3.width += 10
    rm3.height += 20
    print_int(rm3.width) // 15
    print_int(rm3.height) // 25

    // 31.4 Rectangle area after modification
    mut rm4 := Rectangle{
        width:  3
        height: 4
        origin: Point{
            x: 0
            y: 0
        }
    }
    rm4.width *= 10
    rm4.height *= 10
    print_int(rm4.width * rm4.height) // 1200

    // 31.5 Modify struct then pass to function
    mut rm5 := Point{
        x: 5
        y: 10
    }
    rm5.x *= 2
    rm5.y *= 3
    scale_point(mut rm5, 2)
    print_int(rm5.x) // 20
    print_int(rm5.y) // 60

    // ==================== 32. QUADRANT & STRUCT PASSING (5 tests) ====================
    print_str('--- 32. Quadrant & Struct Passing ---')

    // 32.1 Quadrant 1
    print_int(point_quadrant(Point{ x: 5, y: 5 })) // 1

    // 32.2 Quadrant 2
    print_int(point_quadrant(Point{ x: 0 - 5, y: 5 })) // 2

    // 32.3 Quadrant 3
    print_int(point_quadrant(Point{ x: 0 - 5, y: 0 - 5 })) // 3

    // 32.4 Quadrant 4
    print_int(point_quadrant(Point{ x: 5, y: 0 - 5 })) // 4

    // 32.5 Origin
    print_int(point_quadrant(Point{ x: 0, y: 0 })) // 0

    // ==================== 33. 4-FIELD STRUCT (5 tests) ====================
    print_str('--- 33. 4-Field Struct ---')

    // 33.1 Basic Color init
    c1 := Color{
        r: 255
        g: 128
        b: 64
        a: 255
    }
    print_int(c1.r) // 255
    print_int(c1.g) // 128

    // 33.2 Color brightness
    c2 := Color{
        r: 90
        g: 120
        b: 90
        a: 255
    }
    print_int(color_brightness(c2)) // 100

    // 33.3 make_color function return
    c3 := make_color(10, 20, 30, 40)
    print_int(c3.r + c3.g + c3.b + c3.a) // 100

    // 33.4 Color with zero alpha
    c4 := Color{
        r: 100
        g: 200
        b: 50
        a: 0
    }
    print_int(c4.a) // 0
    print_int(c4.b) // 50

    // 33.5 Mutable color
    mut c5 := Color{
        r: 0
        g: 0
        b: 0
        a: 0
    }
    c5.r = 255
    c5.g = 255
    c5.b = 255
    c5.a = 128
    print_int(c5.r + c5.g + c5.b) // 765
    print_int(c5.a) // 128

    // ==================== 34. FIBONACCI ITERATIVE (5 tests) ====================
    print_str('--- 34. Fibonacci Iterative ---')

    // 34.1 Fib(10) iteratively
    mut fa := 0
    mut fb := 1
    for fi := 0; fi < 10; fi++ {
        tmp := fa + fb
        fa = fb
        fb = tmp
    }
    print_int(fa) // 55

    // 34.2 Fib(20) iteratively
    fa = 0
    fb = 1
    for fi := 0; fi < 20; fi++ {
        tmp := fa + fb
        fa = fb
        fb = tmp
    }
    print_int(fa) // 6765

    // 34.3 Sum of first 10 fib numbers
    mut fsum := 0
    fa = 0
    fb = 1
    for fi := 0; fi < 10; fi++ {
        fsum += fa
        tmp := fa + fb
        fa = fb
        fb = tmp
    }
    print_int(fsum) // 88

    // 34.4 Count fib numbers below 100
    mut fcnt := 0
    fa = 0
    fb = 1
    for fa < 100 {
        fcnt++
        tmp := fa + fb
        fa = fb
        fb = tmp
    }
    print_int(fcnt) // 12

    // 34.5 Largest fib below 1000
    fa = 0
    fb = 1
    for fb < 1000 {
        tmp := fa + fb
        fa = fb
        fb = tmp
    }
    print_int(fa) // 987

    // ==================== 35. NESTED LOOPS WITH FLOW CONTROL (5 tests) ====================
    print_str('--- 35. Nested Loops with Flow Control ---')

    // 35.1 Nested with outer break
    mut sum35 := 0
    mut r35 := 0
    for r35 < 10 {
        mut c35 := 0
        for c35 < 10 {
            sum35++
            c35++
        }
        r35++
        if r35 >= 3 {
            break
        }
    }
    print_int(sum35) // 30

    // 35.2 Nested with inner continue
    mut sum35b := 0
    for r35b := 0; r35b < 5; r35b++ {
        for c35b := 0; c35b < 5; c35b++ {
            if c35b % 2 == 0 {
                continue
            }
            sum35b++
        }
    }
    print_int(sum35b) // 10 (5 rows * 2 odd cols)

    // 35.3 Triple nested
    mut sum35c := 0
    for i35 := 0; i35 < 3; i35++ {
        for j35 := 0; j35 < 3; j35++ {
            for k35 := 0; k35 < 3; k35++ {
                sum35c++
            }
        }
    }
    print_int(sum35c) // 27

    // 35.4 Nested with accumulating product
    mut prod35 := 0
    for i35 := 1; i35 <= 3; i35++ {
        for j35 := 1; j35 <= 3; j35++ {
            prod35 += i35 * j35
        }
    }
    print_int(prod35) // 36

    // 35.5 Skip diagonal
    mut sum35d := 0
    for i35 := 0; i35 < 4; i35++ {
        for j35 := 0; j35 < 4; j35++ {
            if i35 == j35 {
                continue
            }
            sum35d++
        }
    }
    print_int(sum35d) // 12

    // ==================== 36. COMPLEX MATCH (5 tests) ====================
    print_str('--- 36. Complex Match ---')

    // 36.1 Match with function call in body
    x36 := 3
    match x36 {
        1 { print_int(fib(5)) }
        2 { print_int(fib(6)) }
        3 { print_int(fib(7)) }
        else { print_int(0) }
    }

    // 13

    // 36.2 Match with computation in body
    x36b := 2
    match x36b {
        1 { print_int(10 * 10) }
        2 { print_int(20 * 20) }
        3 { print_int(30 * 30) }
        else { print_int(0) }
    }

    // 400

    // 36.3 Match on computed value
    x36c := 15 % 4
    match x36c {
        0 { print_int(100) }
        1 { print_int(200) }
        2 { print_int(300) }
        3 { print_int(400) }
        else { print_int(500) }
    }

    // 400

    // 36.4 Match in loop
    mut sum36 := 0
    for i36 := 0; i36 < 5; i36++ {
        match i36 {
            0 { sum36 += 1 }
            1 { sum36 += 10 }
            2 { sum36 += 100 }
            else { sum36 += 1000 }
        }
    }
    print_int(sum36) // 1 + 10 + 100 + 1000 + 1000 = 2111

    // 36.5 Sequential matches
    mut r36 := 0
    x36d := 5
    match x36d {
        5 { r36 += 100 }
        else { r36 += 1 }
    }

    match x36d {
        5 { r36 += 200 }
        else { r36 += 2 }
    }

    print_int(r36) // 300

    // ==================== 37. CHAINED FUNCTION CALLS (5 tests) ====================
    print_str('--- 37. Chained Function Calls ---')

    // 37.1 add(add(add(1,2),3),4) = 10
    print_int(add(add(add(1, 2), 3), 4)) // 10

    // 37.2 Nested mul and add
    print_int(add(mul(3, 4), mul(5, 6))) // 42

    // 37.3 sub(mul(add(2,3),4),5) = 15
    print_int(sub(mul(add(2, 3), 4), 5)) // 15

    // 37.4 min of max
    print_int(min_val(max_val(10, 20), max_val(5, 15))) // 15

    // 37.5 max of min
    print_int(max_val(min_val(10, 20), min_val(25, 30))) // 25

    // ==================== 38. MIXED ARITHMETIC (5 tests) ====================
    print_str('--- 38. Mixed Arithmetic ---')

    // 38.1 Shift + add
    print_int((1 << 8) + 1) // 257

    // 38.2 Bitwise + arithmetic
    print_int((0xFF & 0x0F) + 16) // 31

    // 38.3 Modulo + multiply
    print_int((100 % 7) * 10) // 20

    // 38.4 Shift + bitwise
    print_int((1 << 4) | (1 << 2)) // 20

    // 38.5 Complex expression
    v38 := 100
    print_int((v38 * 2 + v38 / 2) - (v38 % 3)) // 249

    // ==================== 39. LARGE COMPUTATIONS (5 tests) ====================
    print_str('--- 39. Large Computations ---')

    // 39.1 Large factorial (10!)
    mut lf := 1
    for li := 1; li <= 10; li++ {
        lf *= li
    }
    print_int(lf) // 3628800

    // 39.2 Power of 2^20
    mut lp := 1
    for li := 0; li < 20; li++ {
        lp *= 2
    }
    print_int(lp) // 1048576

    // 39.3 Sum of squares 1..20
    mut lsq := 0
    for li := 1; li <= 20; li++ {
        lsq += li * li
    }
    print_int(lsq) // 2870

    // 39.4 Triangular number T(100)
    mut tri := 0
    for li := 1; li <= 100; li++ {
        tri += li
    }
    print_int(tri) // 5050

    // 39.5 Product of 1..8
    print_int(mul_many(1, 2, 3, 4, 5, 6, 7, 8)) // 40320

    // ==================== 40. INTEGRATION TEST (5 tests) ====================
    print_str('--- 40. Integration Test ---')

    // 40.1 Struct + loop + function
    mut ip := make_point(0, 0)
    for ii := 1; ii <= 5; ii++ {
        ip = add_points(ip, make_point(ii, ii * 2))
    }
    print_int(ip.x) // 15
    print_int(ip.y) // 30

    // 40.2 Conditional + struct + global
    g_val = 0
    mut ip2 := Point{
        x: 1
        y: 1
    }
    for ii := 0; ii < 10; ii++ {
        if ii % 2 == 0 {
            ip2.x += ii
            g_val += 1
        } else {
            ip2.y += ii
        }
    }
    print_int(ip2.x) // 1 + 0 + 2 + 4 + 6 + 8 = 21
    print_int(ip2.y) // 1 + 1 + 3 + 5 + 7 + 9 = 26
    print_int(g_val) // 5

    // 40.3 Nested function + assert
    assert abs_val(0 - 42) == 42
    assert min_val(10, 20) == 10
    assert max_val(10, 20) == 20
    print_str('Integration asserts passed')

    // 40.4 Algorithm + match
    mut sum40 := 0
    for ii := 1; ii <= 10; ii++ {
        match classify(ii * 10) {
            1 { sum40 += 1 }
            2 { sum40 += 10 }
            3 { sum40 += 100 }
            else { sum40 += 0 }
        }
    }
    print_int(sum40) // 10: 1, 20: 1, 30: 1, 40: 1, 50: 1, 60: 10, 70: 10, 80: 10, 90: 10, 100: 10 = 5 + 50 = 55
    // Actually: 10->1, 20->1, 30->1, 40->1, 50->1, 60->2(>50), 70->2, 80->2, 90->2, 100->2(not >100)
    // so: 1*5 + 10*5 = 55

    // 40.5 Heap struct in loop with accumulation
    mut hsum := 0
    for ii := 0; ii < 5; ii++ {
        hp := &Point{
            x: ii * 3
            y: ii * 7
        }
        hsum += hp.x + hp.y
    }
    print_int(hsum) // (0+0)+(3+7)+(6+14)+(9+21)+(12+28) = 0+10+20+30+40 = 100

    // ==================== 41. VECTOR MATH (5 tests) ====================
    print_str('--- 41. Vector Math ---')

    va := Vec3{
        x: 1
        y: 2
        z: 3
    }
    vb := Vec3{
        x: 4
        y: 5
        z: 6
    }
    print_int(vec3_dot(va, vb)) // 1*4+2*5+3*6 = 32
    print_int(vec3_len_sq(va)) // 1+4+9 = 14
    vsum := vec3_add(va, vb)
    print_int(vsum.x) // 5
    print_int(vsum.y) // 7
    print_int(vsum.z) // 9

    // ==================== 42. VECTOR SCALE & CROSS (5 tests) ====================
    print_str('--- 42. Vector Scale & Cross ---')

    vs := vec3_scale(va, 3)
    print_int(vs.x) // 3
    print_int(vs.y) // 6
    print_int(vs.z) // 9
    print_int(vec3_cross_z(va, vb)) // 1*5 - 2*4 = -3
    vc := vec3_add(vec3_scale(va, 2), vec3_scale(vb, 3))
    print_int(vc.x) // 2+12 = 14

    // ==================== 43. MATRIX OPERATIONS (5 tests) ====================
    print_str('--- 43. Matrix Operations ---')

    m1 := Matrix2x2{
        a: 1
        b: 2
        c: 3
        d: 4
    }
    m2 := Matrix2x2{
        a: 5
        b: 6
        c: 7
        d: 8
    }
    print_int(mat_det(m1)) // 1*4-2*3 = -2
    print_int(mat_trace(m1)) // 1+4 = 5
    m3 := mat_mul(m1, m2)
    print_int(m3.a) // 1*5+2*7 = 19
    print_int(m3.b) // 1*6+2*8 = 22
    print_int(m3.d) // 3*6+4*8 = 50

    // ==================== 44. PRIME CHECKING (5 tests) ====================
    print_str('--- 44. Prime Checking ---')

    mut prime_count := 0
    for ii := 2; ii <= 30; ii++ {
        if is_prime(ii) {
            prime_count++
        }
    }
    print_int(prime_count) // primes: 2,3,5,7,11,13,17,19,23,29 = 10

    if is_prime(97) {
        print_int(1)
    } else {
        print_int(0)
    } // 1
    if is_prime(100) {
        print_int(1)
    } else {
        print_int(0)
    } // 0
    if is_prime(2) {
        print_int(1)
    } else {
        print_int(0)
    } // 1
    if is_prime(1) {
        print_int(1)
    } else {
        print_int(0)
    } // 0

    // ==================== 45. INTEGER SQUARE ROOT (5 tests) ====================
    print_str('--- 45. Integer Square Root ---')

    print_int(isqrt(0)) // 0
    print_int(isqrt(1)) // 1
    print_int(isqrt(4)) // 2
    print_int(isqrt(100)) // 10
    print_int(isqrt(99)) // 9

    // ==================== 46. REVERSE & PALINDROME (5 tests) ====================
    print_str('--- 46. Reverse & Palindrome ---')

    print_int(reverse_int(12345)) // 54321
    print_int(reverse_int(100)) // 1
    print_int(count_digits(12345)) // 5
    if is_palindrome_num(12321) {
        print_int(1)
    } else {
        print_int(0)
    } // 1
    if is_palindrome_num(12345) {
        print_int(1)
    } else {
        print_int(0)
    } // 0

    // ==================== 47. STATS TRACKING (5 tests) ====================
    print_str('--- 47. Stats Tracking ---')

    mut st_min := 0
    mut st_max := 0
    mut st_sum := 0
    mut st_cnt := 0
    // Inline stats tracking for values: 10, 3, 25, 7, 15
    // val=10
    st_min = 10
    st_max = 10
    st_sum = 10
    st_cnt = 1
    // val=3
    if 3 < st_min { st_min = 3 }
    if 3 > st_max { st_max = 3 }
    st_sum += 3
    st_cnt++
    // val=25
    if 25 < st_min { st_min = 25 }
    if 25 > st_max { st_max = 25 }
    st_sum += 25
    st_cnt++
    // val=7
    if 7 < st_min { st_min = 7 }
    if 7 > st_max { st_max = 7 }
    st_sum += 7
    st_cnt++
    // val=15
    if 15 < st_min { st_min = 15 }
    if 15 > st_max { st_max = 15 }
    st_sum += 15
    st_cnt++
    print_int(st_min) // 3
    print_int(st_max) // 25
    print_int(st_sum) // 60
    print_int(st_cnt) // 5
    print_int(st_sum / st_cnt) // 12

    // ==================== 48. BINARY SEARCH (5 tests) ====================
    print_str('--- 48. Binary Search ---')

    print_int(binary_search_step(30, 0, 4, 10, 20, 30, 40, 50)) // 2
    print_int(binary_search_step(10, 0, 4, 10, 20, 30, 40, 50)) // 0
    print_int(binary_search_step(50, 0, 4, 10, 20, 30, 40, 50)) // 4
    print_int(binary_search_step(35, 0, 4, 10, 20, 30, 40, 50)) // -1
    print_int(binary_search_step(40, 0, 4, 10, 20, 30, 40, 50)) // 3

    // ==================== 49. ACKERMANN FUNCTION (5 tests) ====================
    print_str('--- 49. Ackermann Function ---')

    print_int(ackermann(0, 0)) // 1
    print_int(ackermann(1, 1)) // 3
    print_int(ackermann(2, 2)) // 7
    print_int(ackermann(3, 2)) // 29
    print_int(ackermann(0, 5)) // 6

    // ==================== 50. TRIANGLE & GEOMETRY (5 tests) ====================
    print_str('--- 50. Triangle & Geometry ---')

    print_int(triangle_area_2x(0, 0, 4, 0, 0, 3)) // 12 (area=6, 2x=12)
    print_int(triangle_area_2x(0, 0, 10, 0, 0, 10)) // 100
    rp := rotate_point_90(Point{ x: 3, y: 4 })
    print_int(rp.x) // -4
    print_int(rp.y) // 3
    print_int(manhattan_dist(Point{ x: 1, y: 2 }, Point{
        x: 4
        y: 6
    })) // 3+4 = 7

    // ==================== 51. DIGITAL ROOT (5 tests) ====================
    print_str('--- 51. Digital Root ---')

    print_int(digital_root(0)) // 0
    print_int(digital_root(5)) // 5
    print_int(digital_root(39)) // 3+9=12, 1+2=3