; x86-64 Assembly (NASM Syntax - Intel)
global _start
section .text
_start:
    mov rax, 42          ; Load immediate integer 42 into register RAX
    add rax, 58          ; RAX = 42 + 58 = 100
    ret

; =========================================================================
; ARM64 Assembly (AArch64 - Apple Silicon / Linux ARM)
.global _start
.align 2
_start:
    mov x0, #42          ; Load immediate integer 42 into register X0
    add x0, x0, #58      ; X0 = 42 + 58 = 100
    ret

; System V AMD64 ABI Function: int64_t compute_sum(int64_t a, int64_t b)
; Parameters: RDI = a, RSI = b | Return value: RAX
global compute_sum
compute_sum:
    push rbp             ; Save caller base frame pointer
    mov rbp, rsp         ; Establish new stack frame
    
    mov rax, rdi         ; RAX = a
    add rax, rsi         ; RAX = a + b (Return value in RAX!)
    
    pop rbp              ; Restore base pointer
    ret                  ; Pop return address from stack and jump

; Array lookup: arr[i] where base=RBX, i=RCX (Scale=8 bytes for 64-bit int)
mov rax, [rbx + rcx * 8 + 16]   ; Complex SIB (Scale-Index-Base) addressing!

; RIP-Relative Addressing (Mandatory for Position-Independent Executables - PIE)
mov rax, [rel global_config_flag]

; Branchless Minimum: min(a, b) where RDI = a, RSI = b
global fast_min
fast_min:
    cmp rdi, rsi         ; Compare a and b (Sets RFLAGS ZF, SF, OF, CF)
    mov rax, rsi         ; Assume b is smaller (RAX = b)
    cmovle rax, rdi      ; If a <= b, move a into RAX in 1 single CPU cycle!
    ret                  ; ZERO branch misprediction possible!

; AVX2 Vectorized Float Addition (Processes 8 Float32s in 1 single clock cycle!)
global avx_vector_add
avx_vector_add:
    vmovups ymm0, [rdi]        ; Load 8 floats from array A into 256-bit YMM0
    vmovups ymm1, [rsi]        ; Load 8 floats from array B into 256-bit YMM1
    vaddps  ymm2, ymm0, ymm1   ; Parallel SIMD vector add (8 additions at once!)
    vmovups [rdx], ymm2        ; Store result into destination pointer RDX
    vzeroupper                 ; Clean up upper YMM state to avoid AVX-SSE penalty
    ret

; Standalone 100% Pure Assembly Linux Executable (Zero C standard library!)
section .data
    msg db "Hello, Production Machine Code!", 10
    len equ $ - msg

section .text
global _start
_start:
    ; sys_write(int fd, const void *buf, size_t count)
    mov rax, 1           ; Syscall 1 = sys_write
    mov rdi, 1           ; FD 1 = stdout
    mov rsi, msg         ; Buffer pointer
    mov rdx, len         ; Byte count
    syscall              ; Ring 3 -> Ring 0 Kernel Trap!

    ; sys_exit(int status)
    mov rax, 60          ; Syscall 60 = sys_exit
    xor rdi, rdi         ; Exit code 0
    syscall