class Stack
  def initialize(stack = [])
    @fifo = stack
  end
  def ld(o); @fifo << o; end
  def pop; @fifo.pop; end
  def peek; @fifo.last; end
  def size; @fifo.size; end
  def to_s; @fifo.to_s; end
  def eql?(o); @fifo.eql?(o); end
  def <<(o); ld o; end
end

def Stack.mk_binary_op(name, &operator)
  define_method(name) do
    op2 = pop; op1 = pop
    ld operator.call(op1, op2)
  end
end

class Stack
  mk_binary_op :sub, &:-
  mk_binary_op :add, &:+
  mk_binary_op :mul, &:*
  mk_binary_op :div, &:/
  mk_binary_op :bitwise_or, &:|
end

section .rodata
fmt db `%s %i\n`, 0x0

section .data
msg db "Hello, world!", 0x0

section .text

extern printf

global _start
global main
global print

_start:
        mov ebp, esp

        ; arguments to main:
        ; _start(int argc, char **argv)
        call main

        ; exit(eax)
        mov ebx, eax
        mov eax, 1
        int 0x80

print:
        push ebp
        mov ebp, esp

        mov ecx, 100
        add ecx, 1
        push ecx
        push msg
        push fmt
        call printf

        ; clean-up for `printf' call   
        ; increase stack pointer by argument size
        ; to simply ignore them
        ; sizeof(int) + sizeof(char *) * 2
        add esp, 12 

        leave
        ret

main:
        push ebp
        mov ebp, esp

        call print

        xor eax, eax
        leave 
        ret  

  mov ebx, 100
  mov edi, 0

loop:

  push edi
  call BEL
  call printN

  inc edi
  cmp edi, ebx
  jnz loop

  call printLn

  xor eax, eax
  leave
  ret

BEL:                                    # @BEL
        lea     eax, [4*rdi - 4]
        cdqe
        imul    rax, rax, 1431655766
        mov     rcx, rax
        shr     rcx, 63
        shr     rax, 32
        add     eax, ecx
        or      eax, 3
        add     eax, 2
        ret

BEL:                                    # @BEL
        push    rbp
        mov     rbp, rsp
        mov     dword ptr [rbp - 4], edi
        mov     edi, dword ptr [rbp - 4]
        sub     edi, 1
        shl     edi, 2
        mov     eax, edi
        cdq
        mov     edi, 3
        idiv    edi
        or      eax, 3
        add     eax, 2
        pop     rbp
        ret