asmfn invoke_x86_64_exit_syscall() void
@asmsyntax("AT&T") @convention("C")
{
    "mov $$60, %rax",
    "mov $$1, %rdi",
    "syscall"
} { 
    "~{rax}~{rdi}"
}

fn main() s32 @public {
    invoke_x86_64_exit_syscall();
    return 0;
}

// ******************************************************************************************
//
//   Hello World!
//
// ******************************************************************************************

// Thrush Programming Language - File extensions
// 
// - '.🐦'
// - '.thrush'
//

// External declaration for the C printf function
fn print(fmt: const ptr[array[char]]) s32 @public @ignore @extern("printf") @convention("C");

fn main() s32 @public {

    print("Hello World!");         
    return 0;

}

// ******************************************************************************************
//
//   Fibonacci - O(2^n)
//
// ******************************************************************************************

// Thrush Programming Language - File extensions
// 
// - '.🐦'
// - '.thrush'
//

// External declaration for the C printf function
fn print(fmt: const ptr[array[char]]) s32 @public @ignore @extern("printf") @convention("C");

// Computes the nth Fibonacci number recursively
//
// Parameters:
//   n: The index of the Fibonacci number to compute (unsigned 32-bit integer)
//
// Returns: The nth Fibonacci number (unsigned 32-bit integer)
//
// Attributes:
//   @hot: Marks the function as frequently executed, encouraging aggressive optimizations. 
//   @inline:
//         Maps to LLVM's 'inlinehint', suggesting the compiler inline this function
//         at call sites to reduce call overhead. May increase code size, and may be
//         limited for deep recursion.
//   @nounwind:
//         Maps to LLVM's 'nounwind', guaranteeing the function will not unwind the stack
//         (i.e., it will not throw an exception or cause an abnormal termination
//         that requires stack unwinding). This enables significant optimizations.
//
fn fibonacci(n: u32) u32
@hot
@inline
@nounwind
{
    if n <= 1 {
        return n;
    }

    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Prints the first n Fibonacci numbers
// Parameters:
//   n: The number of Fibonacci numbers to print (unsigned 32-bit integer)
fn printFibonacci(n: u32) void {
    for local mut i: u32 = 0; i < n; ++i; {
        print("%d\n", fibonacci(i));
    }
}

fn main(argc: u32, argv: ptr[array[char]]) s32 @public {

    print("Fibonacci sequence: ");         
    printFibonacci(25);            

    return 0;
}

// ******************************************************************************************
//
//   100 MILLIONS ARRAY UPDATES 
//
// ******************************************************************************************

fn atoi(str: const ptr[array[char]]) s32 @public @ignore @extern("atoi") @convention("C");
fn srand(seed: u32) void @public @extern("srand") @convention("C");
fn time(timer: ptr) u32 @public @extern("time") @convention("C"); 
fn rand() s32 @public @extern("rand") @convention("C");
fn print(fmt: const ptr[array[char]]) s32 @public @ignore @extern("printf") @convention("C");

fn main(argc: s32, argv: ptr[array[char]]) s32 @public {

    local mut u: s32 = atoi(deref (argv[1] as const ptr[array[char]])); 

    srand(time(nullptr)); 
  
    local mut r: s32 = rand() % 10000; 
    local mut a: array[s32; 10000]; 

    for local mut i: s32 = 0; i < 10000; i++; {
        for local mut j: s32 = 0; j < 100000; j++; {
            a[i] = (deref a[i]) + ((j % u));             
        }

        a[i] = (deref a[i]) + r;
    }

    print("%ld\n", deref a[r]); 

    return 0;

}