// Signed integers
i8      // -128 to 127
i16     // -32,768 to 32,767
i32     // -2,147,483,648 to 2,147,483,647
i64     // -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

// Unsigned integers
u8      // 0 to 255
u16     // 0 to 65,535
u32     // 0 to 4,294,967,295
u64     // 0 to 18,446,744,073,709,551,615

// Other types
bool    // 0 or 1 (u8)
ptr     // 64-bit pointer

// Immutable by default
let x: i32 = 10;

// Mutable variables
let mut y: i32 = 20;
y = y + 5;  // OK

// Initialization is optional
let z: i32;  // Uninitialized (use with care)

// Basic function
fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

// No return value
fn print_something() {
    // ...
}

// Entry point (must return i32)
fn main() -> i32 {
    return 0;
}

fn abs(x: i32) -> i32 {
    if x < 0 {
        return -x;
    } else {
        return x;
    }
}

// Without else
fn positive_check(x: i32) -> bool {
    if x > 0 {
        return 1;
    }
    return 0;
}

fn count() -> i32 {
    let mut i: i32 = 0;
    
    while i < 10 {
        i = i + 1;
    }
    
    return i;  // 10
}

fn find_even() -> i32 {
    let mut i: i32 = 0;
    
    while i < 100 {
        i = i + 1;
        
        if i == 50 {
            break;  // Exit loop
        }
        
        if i < 10 {
            continue;  // Skip to next iteration
        }
    }
    
    return i;
}

let a: i32 = 10 + 5;   // Addition
let b: i32 = 10 - 5;   // Subtraction
let c: i32 = 10 * 5;   // Multiplication (MVP: not implemented)
let d: i32 = 10 / 5;   // Division (MVP: not implemented)
let e: i32 = -10;      // Negation

x == y    // Equal
x != y    // Not equal
x < y     // Less than
x <= y    // Less than or equal
x > y     // Greater than
x >= y    // Greater than or equal

x = y     // Simple assignment
x = x + 1 // Compound expression

// Decimal
let dec: i32 = 42;

// Hexadecimal
let hex: i32 = 0xFF;      // 255
let hex2: i32 = 0x1A2B;   // 6699

// Binary
let bin: i32 = 0b1010;    // 10
let bin2: i32 = 0b11111111; // 255

// Negative
let neg: i32 = -100;

// Underscores for readability (ignored)
let big: i32 = 1_000_000;

// Single-line comments only
// Multi-line comments: use multiple single-line comments

fn example() -> i32 {
    // This is a comment
    let x: i32 = 10;  // Inline comment
    return x;
}

fn main() -> i32 {
    return 42;
}

fn main() -> i32 {
    let x: i32 = 10;
    let y: i32 = 20;
    let z: i32 = x + y;
    return z;  // 30
}

fn factorial(n: i32) -> i32 {
    let mut result: i32 = 1;
    let mut i: i32 = 1;
    
    while i <= n {
        result = result * i;
        i = i + 1;
    }
    
    return result;
}

fn main() -> i32 {
    return factorial(5);  // 120
}

fn max(a: i32, b: i32) -> i32 {
    if a > b {
        return a;
    }
    return b;
}

fn clamp(x: i32, min: i32, max: i32) -> i32 {
    if x < min {
        return min;
    }
    if x > max {
        return max;
    }
    return x;
}

fn is_prime(n: i32) -> bool {
    if n <= 1 {
        return 0;
    }
    
    let mut i: i32 = 2;
    while i < n {
        // Note: modulo operator not implemented in MVP
        // This is pseudocode for demonstration
        i = i + 1;
    }
    
    return 1;
}

fn count_primes(limit: i32) -> i32 {
    let mut count: i32 = 0;
    let mut i: i32 = 2;
    
    while i < limit {
        if is_prime(i) == 1 {
            count = count + 1;
        }
        i = i + 1;
    }
    
    return count;
}

fn main() -> i32 {
    return count_primes(100);
}