WebSVN – Kolibri OS – Path Comparison – / – /programs/develop Rev 5094 and /programs/develop Rev 5098

Regard whitespace Rev 5094 → Rev 5098

/programs/develop/SPForth/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"meforth.ASM", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "meforth")

/programs/develop/asciivju/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("asciivju.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "asciivju")

/programs/develop/cObj/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"cObj.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "cObj")

/programs/develop/examples/checkbox/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("checkbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "checkbox")

/programs/develop/examples/circle/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("circle.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "circle")

/programs/develop/examples/clipboard/Tupfile.lua
0,0 → 1,6
if tup.getconfig("NO_FASM") ~= "" then return end
tup.foreach_rule(
{"clip_get.asm", "clip_put.asm"},
"fasm %f %o " .. tup.getconfig("KPACK_CMD"),
"%B"
)

/programs/develop/examples/cpuspeed/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"cpuspeed.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "cpuspeed")

/programs/develop/examples/editbox/trunk/EDITBOX.INC
File deleted
\ No newline at end of file

/programs/develop/examples/editbox/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("editbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "editbox")

 /programs/develop/examples/editbox/trunk/editbox.inc
 ,0 → 1,271
+; SEE YOU File FAQ.txt and HISTORY. Good Like!
+;;;;;;;;;;;;;;;;;;
+include 'editbox.mac'    ;¬ ªà®á ª®â®àë© ¤®«¦¥ ®¡«¥£ç¨âì ¦¨§ì :) á¯¥æ¨ «ì® ¤«ï editbox
+;;;;;;;;;;;;;;;;;;
+macro use_edit_box
+{
+edit_box:
+ed_width        equ [edi]               ;è¨à¨  ª®¬¯®¥â
+ed_left         equ [edi+4]             ;¯®«®¦¥¨¥ ¯® ®á¨ å
+ed_top          equ [edi+8]             ;¯®«®¦¥¨¥ ¯® ®á¨ ã
+ed_color        equ [edi+12]            ;æ¢¥â ä®  ª®¬¯®¥â
+shift_color     equ [edi+16]            ;=0x6a9480
+ed_focus_border_color   equ [edi+20]    ;æ¢¥â à ¬ª¨ ª®¬¯®¥â
+ed_blur_border_color    equ [edi+24]    ;æ¢¥â ¥  ªâ¨¢®£® ª®¬¯®¥â
+ed_text_color   equ [edi+28]            ;æ¢¥â â¥ªáâ
+ed_max          equ [edi+32]                    ;ª®«-¢® á¨¬¢®«®¢ ª®â®àë¥ ¬®¦® ¬ ªá¨¬ «ì® ¢¢¥áâ¨
+ed_text         equ [edi+36]                    ;ãª § â¥«ì   ¡ãä¥à
+ed_flags        equ [edi+40]            ;ä« £¨
+ed_size equ [edi+44]                    ;ª®«-¢® á¨¬¢®«®¢
+ed_pos  equ [edi+48]                    ;¯®§¨æ¨ï ªãàá®à
+ed_offset       equ [edi+52]            ;á¬¥é¥¨¥
+cl_curs_x       equ [edi+56]            ;¯à¥¤ë¤ãé¥¥ ª®®à¤¨ â  ªãàá®à  ¯® å
+cl_curs_y       equ [edi+60]            ;¯à¥¤ë¤ãé¥¥ ª®®à¤¨ â  ªãàá®à  ¯® ã
+ed_shift_pos    equ [edi+64]            ;¯®«®¦¥¨¥ ªãàá®à
+ed_shift_pos_old equ [edi+68]           ;áâ à®¥ ¯®«®¦¥¨¥ ªãàá®à
+;==========================================================
+;=== ¯à®æ¥¤ãà  ¯à®à¨á®¢ª¨ =================================
+;==========================================================
+.draw:
+pushad
+;--- à¨áã¥¬ à ¬ªã ---
+        call    .draw_border            ; ãªæ¨ï áâ ¡¨«ì
+.draw_bg_cursor_text:
+;--- ¨§¬¥ï¥¬ á¬¥é¥¨¥, ¥á«¨  ¤® ---
+        call    .check_offset           ;¢ëç¨á«¥¨¥ ¯®§¨æ¨¨ ªãàá®à  áâ ¡¨«ì
+;--- à¨áã¥¬ ¢ãâà¥îî ®¡« áâì ---
+        call    .draw_bg                ; à¨á®¢ âì ¯àï¬®ã£®«ì¨ª à ¡®ç¥© ®¡« áâ¨
+;---- à¨áã¥¬ ¢ë¤¥«¥¨¥, ¯® shift ¥á«¨ ¥áâì
+        call    .draw_shift
+.draw_cursor_text:
+;--- à¨áã¥¬ ªãàá®à ---
+        ;--- ¬®¦¥â ¥£® ¥  ¤® à¨á®¢ âì ----
+        test    word ed_flags,ed_focus
+        je     @f
+        call    .draw_cursor
+@@:
+        call    .draw_text
+;;;;;;;;;;;;;;;;;;;;;;;;;;
+;¡é¨© ¢ëå®¤ ¨§ editbox ¤«ï ¢á¥å äãªæ¨© ¨ ¯®áâ ®¡à ¡®âç¨ª®¢
+;;;;;;;;;;;;;;;;;;;;;;;;;;
+.editbox_exit:
+edit_ex
+;==========================================================
+;=== ®¡à ¡®âª  ª« ¢¨ âãàë =================================
+;==========================================================
+.key:
+pushad
+        test    word ed_flags,ed_focus ; ¥á«¨ ¥ ¢ ä®ªãá¥, ¢ëå®¤¨¬
+        je      .editbox_exit
+        test    word ed_flags,ed_mouse_on
+        jne     .editbox_exit
+;à®¢¥àª   ¦ â shift ?
+        call    .check_shift
+;----------------------------------------------------------
+;--- ¯à®¢¥àï¥¬, çâ®  ¦ â® --------------------------------
+;----------------------------------------------------------
+use_key_process  backspase,delete,left,right,home,end,insert
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; £«ãèª    ®¡à ¡®âªã ª« ¢¨è ¢¢¥àå ¨ ¢¨§ â.¥. ¯à¨ ®¡ àã¦¥¨¨ íâ¨å ª®¤®¢ ¯à®¨áå®¤¨â ¢ëå®¤ ¨§ ®¡à ¡®âç¨ª
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+use_key_no_process   up,down,esc,enter,tab,numl,capsl,scrolll
+;---  ¦ â  ¤àã£ ï ª« ¢¨è  ---
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;à®¢¥àª  ãáâ ®¢«¥ «¨ ä« £ ¯à¨ ª®â®à®¬ ã¦® ¢ë¢®¤¨âì â®«ìª® æ¨äàë ¢ ã¦®¬ ¡®ªá¥ ¥á«¨ â ª®©¥®¡å®¤¨¬®áâ¨ ¥â ã¦® § ª®¬¥â¨à®¢ âì ¬ ªà®á
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+use_key_figures_only
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;¯à®¢¥àª    shift ¡ë« «¨  ¦ â
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+are_key_shift_press
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; ¯à®¢¥àï¥¬,  å®¤¨âáï «¨ ªãàá®à ¢ ª®æ¥ + ¤ «ì¥©è ï ®¡à ¡®âª
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+are_key_cur_end
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;¡à ¡®âª  ª« ¢¨è insert,delete.backspase,home,end,left,right
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+use_work_key
+;==========================================================
+;=== ®¡à ¡®âª  ¬ëè¨ =======================================
+;==========================================================
+.mouse:
+pushad
+;debug
+;----------------------------------------------------------
+;--- ¯®«ãç ¥¬ á®áâ®ï¨¥ ª®¯®ª ¬ëè¨ -----------------------
+;----------------------------------------------------------
+        mcall   37,2
+;----------------------------------------------------------
+;--- ¯à®¢¥àï¥¬ á®áâ®ï¨¥ ----------------------------------
+;----------------------------------------------------------
+        test    eax,1
+        jnz     .mouse_left_button
+        and     word ed_flags,ed_mouse_on_off
+        xor     ebx,ebx
+        mov     dword [mouse_flag],ebx
+        jmp     .editbox_exit
+.mouse_left_button:
+;----------------------------------------------------------
+;--- ¡«®ª¨à®¢ª  ®â ä®ªãá¨à®¢ª¨ ¢ ¤àã£¨å ¡®ªá å ¯à¨ ¯®¯ ¤ ¨¨   ¨å ªãàá®à
+;----------------------------------------------------------
+        mov     eax,dword [mouse_flag]
+        test    eax,eax
+        jz      @f
+        cmp     eax,edi
+        je      @f
+        jmp     ._blur
+;----------------------------------------------------------
+;--- ¯®«ãç ¥¬ ª®®à¤¨ âë ¬ëè¨ ®â®á¨â¥«ì® ®ª
+;----------------------------------------------------------
+@@:     mcall   37,1
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;ãªæ¨ï ®¡à ¡®âª¨  ¬ëèª¨ ¯®«ãç¥¨¥ ª®®à¤¨ â ¨ ¯à®¢¥àª  ¨å + ¢ë¤¥«¥¨ï
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+use_work_mouse
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;¡é¨¥ äãªæ¨¨ ®¡à ¡®âª¨
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+use_general_func
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;ãªæ¨¨ ¤«ï à ¡®âë á key
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+use_key_func
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;ãªæ¨¨ ¤«ï à ¡®âë á mouse
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+use_mouse_func
+}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;Bit mask from editbox
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ed_figure_only= 1000000000000000b   ;®¤¨ á¨¬¢®«ë
+ed_always_focus= 100000000000000b
+ed_focus=                     10b   ;ä®ªãá ¯à¨«®¦¥¨ï
+ed_shift_on=                1000b   ;¥á«¨ ¥ ãáâ ®¢«¥ -§ ç¨â ¢¯¥à¢ë¥  ¦ â shift,¥á«¨ ¡ë« ãáâ ®¢«¥, § ç¨â ¬ë ã¦¥ çâ® - â® ¤¥« «¨ ã¤¥à¦¨¢ ï shift
+ed_shift_on_off=1111111111110111b
+ed_shift=                    100b   ;¢ª«îç ¥âáï ¯à¨  ¦ â¨¨   shift â.¥. ¥á«¨  ¦¨¬ î
+ed_shift_off=   1111111111111011b
+ed_shift_bac=              10000b   ;¡¨â ¤«ï ®ç¨áâª¨ ¢ë¤¥«¥®£® shift â.¥. ¯à¨ ãáâ ®¢ª¥ £®¢®à¨â çâ® ¥áâì ¢ë¤¥«¥¨¥
+ed_shift_bac_cl=1111111111101111b   ;®ç¨áâª  ¯à¨ ã¤ «¥¨¨ ¢ë¤¥«¥¨ï
+ed_shift_cl=    1111111111100011b
+ed_shift_mcl=   1111111111111011b
+ed_left_fl=               100000b
+ed_right_fl=    1111111111011111b
+ed_offset_fl=            1000000b
+ed_offset_cl=   1111111110111111b
+ed_insert=              10000000b
+ed_insert_cl=   1111111101111111b
+ed_mouse_on =          100000000b
+ed_mous_adn_b=         100011000b
+ed_mouse_on_off=1111111011111111b
+ed_height=14 ; ¢ëá®â
+macro draw_edit_boxes start,_end
+{
+        mov     edi,start
+        mov     ecx,((_end-start)/ed_struc_size)
+@@:
+        call    edit_box.draw
+        add     edi,ed_struc_size
+        loop    @b
+}
+macro mouse_edit_boxes start,_end
+{
+        mov     edi,start
+        mov     ecx,((_end-start)/ed_struc_size)
+@@:
+        call    edit_box.mouse
+        add     edi,ed_struc_size
+        loop    @b
+}
+macro key_edit_boxes start,end
+{
+        mov     edi,start
+        mov     ecx,((end-start)/ed_struc_size)
+@@:
+        call    edit_box.key
+        add     edi,ed_struc_size
+        loop    @b
+}
+ed_struc_size=72
+struc  edit_box width,left,top,color,shift_color,focus_border_color,\
+       blur_border_color,text_color,max,text,flags,size,pos
+{
+.width dd width
+.left dd left
+.top dd top
+.color dd color
+.shift_color dd shift_color
+.focus_border_color dd focus_border_color
+.blur_border_color dd blur_border_color
+.text_color dd text_color
+.max dd max
+.text dd text
+.flags dd flags+0
+.size dd size+0
+.pos dd pos+0
+.offset dd 0
+.cl_curs_x dd 0
+.cl_curs_y dd 0
+.shift   dd 0
+.shift_old   dd 0
+}
+macro edit_boxes_set_sys_color start,end,color_table
+{
+        mov     edi,start
+        mov     ecx,((end-start)/ed_struc_size)
+        mov     esi,color_table
+@@:
+        mov     eax,[esi+36]
+        mov     ebx,[esi+20]
+        mov     ed_focus_border_color,eax
+        shr     bh,1
+        shr     bl,1
+        shr     ah,1
+        shr     al,1
+        add     ah,bh
+        add     al,bl
+        ror     eax,16
+        ror     ebx,16
+        shr     bl,1
+        shr     al,1
+        add     al,bl
+        ror     eax,16
+        mov     ed_blur_border_color,eax
+        add     edi,ed_struc_size
+        loop    @b
+}
+macro draw_edit_box ed_ptr
+{
+        mov     edi,ed_ptr
+        call    edit_box.draw
+}
+macro mouse_edit_box ed_ptr
+{
+        mov     edi,ed_ptr
+        call    edit_box.mouse
+}
+macro key_edit_box ed_ptr
+{
+        mov     edi,ed_ptr
+        call    edit_box.key
+}
+macro default_box ed_ptr
+{
+pusha
+;       xor     eax,eax
+;       mov     ed_shift_pos,eax
+;       mov     ed_shift_pos_old,eax
+        and     word ed_flags,ed_shift_cl
+;       mov     ed_offset,eax
+popa
+}

/programs/develop/examples/example2/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"example2.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "example2")

/programs/develop/examples/example3/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"example3.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "example3")

/programs/develop/examples/hello/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"hello.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "hello")

/programs/develop/examples/ipc/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"ipc.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "ipc")

/programs/develop/examples/ir/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"ir.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "ir")

/programs/develop/examples/numcalc/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("@numcalc.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "@numcalc")

/programs/develop/examples/radiobutton/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("optionbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "optionbox")

/programs/develop/examples/rtdata/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"rtdata.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "rtdata")

/programs/develop/examples/template/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"template.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "template")

/programs/develop/examples/thread/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"thread.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "thread")

/programs/develop/fasm/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"fasm.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "fasm")

/programs/develop/fast_call_test/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("test.ASM", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "test")

/programs/develop/h2d2b/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"h2d2b.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "h2d2b")

/programs/develop/heed/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"heed.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "heed")

/programs/develop/hexview/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"hexview.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "hexview")

/programs/develop/info3ds/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"info3ds.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "info3ds")

/programs/develop/keyascii/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"keyascii.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "keyascii")

/programs/develop/kol_f_edit/Tupfile.lua
0,0 → 1,4
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"kol_f_edit.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "bin/kol_f_edit")
tup.rule({"ob_o.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o", "bin/ob_o.opt")

 /programs/develop/libraries/TinyGL/BeOS/GLView.cpp
 ,0 → 1,205
+#include "GLView.h"
+#include <stdio.h>
+#include <interface/Bitmap.h>
+BLocker BGLView::locker;
+BGLView::BGLView(BRect rect, char *name,
+                 ulong resizingMode, ulong mode,
+                 ulong options)
+  : BView(rect, name, resizingMode, mode|B_FRAME_EVENTS|B_WILL_DRAW)
+{
+#ifdef __INTEL__
+  color_space cs = B_RGB16_LITTLE;
+#else
+  color_space cs = B_RGB16_BIG;
+#endif
+  this->bitmaps[0] = new BBitmap(rect, cs, false, true);
+  this->bitmaps[1] = new BBitmap(rect, cs, false, true);
+  this->currBitmap = 0;
+  int w = this->bitmaps[0]->BytesPerRow() / 2;
+  int h = rect.Height() + 1;
+  void *buffers[2];
+  buffers[0] = this->bitmaps[0]->Bits();
+  buffers[1] = this->bitmaps[1]->Bits();
+  this->context = ostgl_create_context(w, h, 16, buffers, 2);
+  ostgl_make_current(this->context, 0);
+}
+BGLView::~BGLView()
+{
+  ostgl_delete_context(this->context);
+  delete this->bitmaps[0];
+  delete this->bitmaps[1];
+}
+void
+BGLView::LockGL()
+{
+  BGLView::locker.Lock();
+  ostgl_make_current(this->context, this->currBitmap);
+}
+void
+BGLView::UnlockGL()
+{
+  BGLView::locker.Unlock();
+}
+void
+BGLView::SwapBuffers()
+{
+  if (Window()->Lock()) {
+    DrawBitmap(this->bitmaps[this->currBitmap]);
+    Window()->Unlock();
+    this->currBitmap ^= 1;
+  }
+}
+/*
+BView *
+BGLView::EmbeddedView()
+{
+  return NULL;
+}
+status_t
+BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
+{
+  assert(0);
+  return 0;
+}
+status_t
+BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
+{
+  assert(0);
+  return 0;
+}
+*/
+void
+BGLView::ErrorCallback(GLenum /*errorCode*/)
+{
+}
+void
+BGLView::Draw(BRect rect)
+{
+  //fprintf(stderr, "GLView::Draw()");
+  DrawBitmap(this->bitmaps[this->currBitmap^1], rect, rect);
+}
+void
+BGLView::AttachedToWindow()
+{
+}
+void
+BGLView::AllAttached()
+{
+}
+void
+BGLView::DetachedFromWindow()
+{
+}
+void
+BGLView::AllDetached()
+{
+}
+void
+BGLView::FrameResized(float w, float h)
+{
+  delete this->bitmaps[0];
+  delete this->bitmaps[1];
+#ifdef __INTEL__
+  color_space cs = B_RGB16_LITTLE;
+#else
+  color_space cs = B_RGB16_BIG;
+#endif
+  this->bitmaps[0] = new BBitmap(BRect(0,0, w-1, h-1),
+                                 cs, false, true);
+  this->bitmaps[1] = new BBitmap(BRect(0,0, w-1, h-1),
+                                 cs, false, true);
+  int w2 = this->bitmaps[0]->BytesPerRow() / 2;
+  void *buffers[2];
+  buffers[0] = this->bitmaps[0]->Bits();
+  buffers[1] = this->bitmaps[1]->Bits();
+  ostgl_resize(this->context, w2, h, buffers);
+}
+/*
+status_t
+BGLView::Perform(perform_code d, void *arg)
+{
+}
+*/
+//
+// the rest are pass-through functions
+//
+status_t
+BGLView::Archive(BMessage *data, bool deep) const
+{
+  return BView::Archive(data, deep);
+}
+void
+BGLView::MessageReceived(BMessage *msg)
+{
+  BView::MessageReceived(msg);
+}
+void
+BGLView::SetResizingMode(uint32 mode)
+{
+  BView::SetResizingMode(mode);
+}
+void
+BGLView::Show()
+{
+  BView::Show();
+}
+void
+BGLView::Hide()
+{
+  BView::Hide();
+}
+BHandler *
+BGLView::ResolveSpecifier(BMessage *msg, int32 index,
+                          BMessage *specifier, int32 form,
+                                              const char *property)
+{
+  return BView::ResolveSpecifier(msg, index, specifier, form, property);
+}
+status_t
+BGLView::GetSupportedSuites(BMessage *data)
+{
+  return BView::GetSupportedSuites(data);
+}
+/*
+void
+BGLView::DirectConnected( direct_buffer_info *info )
+{
+  BView::DirectConnected(info);
+}
+*/
+/*
+void
+BGLView::EnableDirectMode( bool enabled )
+{
+  BView::EnableDirectMode(enabled);
+}
+*/

 /programs/develop/libraries/TinyGL/BeOS/GLView.h
 ,0 → 1,72
+#ifndef _glview_h_
+#define _glview_h_
+#define BGL_RGB           0
+#define BGL_INDEX         1
+#define BGL_SINGLE        0
+#define BGL_DOUBLE        2
+#define BGL_DIRECT        0
+#define BGL_INDIRECT      4
+#define BGL_ACCUM         8
+#define BGL_ALPHA        16
+#define BGL_DEPTH        32
+#define BGL_OVERLAY      64
+#define BGL_UNDERLAY    128
+#define BGL_STENCIL     512
+#include <interface/View.h>
+#include <support/Locker.h>
+#include <GL/gl.h>
+#include <GL/oscontext.h>
+#include <game/WindowScreen.h>
+#include <game/DirectWindow.h>
+class BGLView : public BView {
+public:
+  BGLView(BRect rect, char *name,
+          ulong resizingMode, ulong mode,
+          ulong options);
+  virtual ~BGLView();
+  void LockGL();
+  void UnlockGL();
+  void SwapBuffers();
+//  BView *EmbeddedView();
+//  status_t CopyPixelsOut(BPoint source, BBitmap *dest);
+//  status_t CopyPixelsIn(BBitmap *source, BPoint dest);
+  virtual void ErrorCallback(GLenum errorCode);
+  virtual void Draw(BRect updateRect);
+  virtual void AttachedToWindow();
+  virtual void AllAttached();
+  virtual void DetachedFromWindow();
+  virtual void AllDetached();
+  virtual void FrameResized(float width, float height);
+//  virtual status_t Perform(perform_code d, void *arg);
+  //
+  // Methods below are pass-throughs to BView for the moment.
+  //
+  virtual status_t Archive(BMessage *data, bool deep = true) const;
+  virtual void MessageReceived(BMessage *msg);
+  virtual void SetResizingMode(uint32 mode);
+  virtual void Show();
+  virtual void Hide();
+  virtual BHandler *ResolveSpecifier(BMessage *msg, int32 index,
+                                                                 BMessage *specifier, int32 form,
+                                                                 const char *property);
+  virtual status_t GetSupportedSuites(BMessage *data);
+  //void DirectConnected( direct_buffer_info *info );
+  //void EnableDirectMode( bool enabled );
+private:
+  ostgl_context *context;
+  BBitmap *bitmaps[2];
+  int currBitmap;
+  static BLocker locker;
+};
+#endif // _glview_h_

 /programs/develop/libraries/TinyGL/BeOS/Makefile
 ,0 → 1,16
+OBJS=GLView.o
+INCLUDES = -I../include
+LIB = libGLView.a
+all: $(LIB)
+$(LIB): $(OBJS)
+        rm -f $(LIB)
+        ar rcs $(LIB) $(OBJS)
+        cp $(LIB) ../lib
+clean:
+        rm -f *~ *.o *.a
+GLView.o: GLView.cpp GLView.h
+        $(CC) $(CFLAGS) $(INCLUDES) -c GLView.cpp

 /programs/develop/libraries/TinyGL/Changelog
 ,0 → 1,48
+version 0.41:   iadn
+- support for KolibriOS (added kosgl.h, kosgl.c,
+  modifications zfeatures.h, glColor4f, glColor4fv, glMaterialfv, glClearColor, ZB_resize)
+- added module glu in library
+- added gluLookAt, RGBFtoRGBI
+- modifications ZB_open, gl_malloc, gl_free, gl_zalloc, gl_get_context
+- fixed bug in gl_draw_line, updateTmp, gl_draw_triangle_clip, zline.h (for INTERP_RGB definition r,g,b )
+- TINYGL library tells where is library extracted
+- build on mingw
+version 0.4:
+ - added 24/32 bit rendering support (Olivier Landemarre - F. Bellard)
+ - fixed GL_TRIANGLE_STRIP (Olivier Landemarre)
+ - added gl_malloc, gl_free, gl_zalloc wrappers (Olivier Landemarre)
+version 0.3:
+ - added NanoX API (nglx) (F. Bellard)
+ - added gears example and unified GUI in examples (F. Bellard)
+ - added TGL_FEATURE_RENDER_BITS so that it will be possible to render
+   natively in 15/16/24 or 32 bits. (F. Bellard)
+ - interpolated lines (Olivier Landemarre)
+ - fast no shading case (Olivier Landemarre)
+ - fast no projection case (Olivier Landemarre)
+version 0.2: Fabrice Bellard
+ - added 24/32 bpp support. Added some features.h ifdefs.
+ - fixed some error reporting cases in the examples
+ - endianness is deduced from the glibc (BYTE_ORDER macro)
+version 0.19: Peder Blekken
+ - new files BeOS/* src/msghandling.*, src/arrays.*, src/oscontext.c
+     include/GL/oscontext.h src/features.h
+ - added support for BeOS, see README.BEOS
+ - added support for drawing convex polygons with unlimited # of vertices
+ - added support for GL_LIGHT_MODEL_TWO_SIDE
+ - added generic rotation code for glopRotate
+ - added support for opengl 1.1 arrays
+ - added support for glPolygonOffset, not implemented.
+ - added glGetFloatv, limited support.
+ - added some pnames for glGetIntegerv
+ - added some empty functions in include/GL/gl.h to compile VRMLView
+ - added GL_VERSION_1_1 define in include/GL/gl.h
+ - fixed "bug" when context->gl_resize_viewport is not set.
+ - fixed bug in glBindTexture (didn't accept texture object 0)
+version 0.1:
+ - Initial revision, Fabrice Bellard

 /programs/develop/libraries/TinyGL/INSTALL
 ,0 → 1,10
+Installation:
+- Edit config.mk and change what is needed. You can also look at
+src/zfeatures.h to change very specific details (only useful to tune
+TinyGL to your needs). You can link the examples with either OpenGL,
+Mesa or TinyGL.
+- Type 'make'. The library 'libTinyGL.a' is copied into './lib'. The
+examples are build in './examples'. Only the directories './lib' and
+'./include' are needed to use TinyGL from another program.

/programs/develop/libraries/TinyGL/Install.ru
0,0 → 1,7
Ó âàñ äîëæíà áûòü óñòàíîâëåíà áèáëèîòåêà menuetlibc äëÿ Êîëèáðè.
Ñîçäàéòå ïåðåìåííóþ TINYGL â êà÷åñòâå çíà÷åíèÿ êîòîðîé çàäàéòå ïóòü
ê äàííîìó êàòàëîãó.
Èç ýòîãî êàòàëîãà âûïîëíèòå êîìàíäó make.
Â ïîäêàòàëîãàõ ðàçìåùåíû
'./include' - çàãîëîâî÷íûå ôàéëû áèáëèîòåêè
'./lib ' - ñêîìïèëèðîâàííàÿ áèáëèîòåêà

 /programs/develop/libraries/TinyGL/LICENCE
 ,0 → 1,22
+Copyright notice:
+ (C) 1997-1998 Fabrice Bellard
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product and its documentation
+     *is* required.
+. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+. This notice may not be removed or altered from any source distribution.
+If you redistribute modified sources, I would appreciate that you
+include in the files history information documenting your changes.

 /programs/develop/libraries/TinyGL/LIMITATIONS
 ,0 → 1,206
+Here are listed the functions that TinyGL understands with the known
+limitations. The non mentionned functions are *not* implemented and
+must not be used.
+************ glEnable / glDisable
+- The following flags are handled:
+GL_CULL_FACE, GL_LIGHTING, GL_COLOR_MATERIAL, GL_TEXTURE_2D, GL_NORMALIZE,
+GL_LIGHTx, GL_POLYGON_OFFSET_FILL, GL_POLYGON_OFFSET_POINT,
+GL_POLYGON_OFFSET_LINE
+- GL_DEPTH_TEST is accepted, but it is only used for lines. For all
+  other primitives, Z buffer use is assumed.  The DepthMode is
+  hardcoded as GL_LESS (OpenGL default).
+************ glShadeModel
+OK.
+************ glCullFace
+OK.
+************ glPolygonMode
+OK.
+************ glBegin
+No tests are performed to prevent some functions of being executed
+between glBegin/glEnd.
+************ glEnd
+OK.
+************ glVertex
+Some prototypes are not implemented.
+************ glColor
+Some prototypes are not implemented.
+************ glNormal
+Some prototypes are not implemented.
+************ glTexCoord
+- Some prototypes are not implemented.
+- The Matrix transformation is not applied yet.
+************ glEdgeFlag
+OK. The edge handling has to be tested, although it is not much useful
+in TinyGL.
+************ glMatrixMode / glLoadMatrixf / glLoadIdentity / glMultMatrixf /
+             glPushMatrix / glPopMatrix / glRotatef / glTranslatef / glScalef /
+             glFrustum
+- The prototypes with doubles are not implemented.
+************ glViewport
+GlViewport calls a function pointers to tell glx (or another display
+system) to resize the Z buffer and the ximage. Made optional in
+version 0.2.
+************ glGenLists / glIsList / glNewList / glEndList / glCallList
+OK.
+************ glClear / glClearColor / glClearDepth
+The whole zbuffer and the colors are cleared in any case. The clear color
+can be redefined, by *not* the initial z value.
+************ glRenderMode
+Only the modes GL_RENDER and GL_SELECT are implemented.
+************ glSelectBuffer / glInitNames / glPushName / glPopName / glLoadName
+OK.
+************ glGenTextures / glDeleteTextures / glBindTexture
+OK. These functions should be used to get the maximum performance with
+TinyGL.
+************ glTexImage2D
+The function accepts only RGB UNSIGNED_BYTES bitmaps. They are
+internally resized to 256x256 so you'd better use that size. No
+mipmapping is implemented although it will come if asked. No borders
+are implemented.
+************ glTexEnvi
+The only supported mode is GL_DECAL, although others are planned if
+asked.
+************ glTexParameteri
+The other prototypes are not implemented. Only the follwing mode are
+implemented:
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+************ glPixelStorei
+The pixels are alware byte aligned.
+************ glMaterialfv / glMaterialf / glColorMaterial
+OK.
+************ glLightfv / glLightf / glLightModeli / glLightModelfv
+OK. The OpenGL lightening is implemented but not optimized.
+************ glFlush
+Ignored.
+************ glHint
+Ignored.
+************ glGetIntegerv
+- only GL_VIEWPORT, GL_MAX_MODELVIEW_STACK_DEPTH,
+GL_MAX_PROJECTION_STACK_DEPTH, GL_MAX_LIGHTS, GL_MAX_TEXTURE_SIZE,
+GL_MAX_TEXTURE_STACK_DEPTH
+************ glGetIntegerv
+- only GL_TEXTURE_MATRIX, GL_PROJECTION_MATRIX, GL_MODELVIEW_MATRIX,
+GL_LINE_WIDTH, GL_LINE_WIDTH_RANGE, GL_POINT_SIZE, GL_POINT_SIZE_RANGE
+************ glPolygonOffset
+- only API implemented.
+************ glEnableClientState, glDisableClientState,
+- No support for GL_INDEX_ARRAY_POINTER or GL_EDGE_FLAG_ARRAY_POINTER
+************ glVertexPointer, glNormalPointer,
+             glColorPointer, glTexureCoordPointer
+- OK
+------------------------------------------------------------------------------
+TinyGL GLX emulation:
+************ glXQueryExtension
+Returns always True
+************ glXChooseVisual
+Only 8 bit Pseudocolor or 16 bit Truecolor Visual are accepted. The
+attribute list is ignored.
+************ glXCreateContext
+The sharing is not implemented although the code could handle it.
+************ glXDestroyContext
+OK.
+************ glXMakeCurrent
+Not all the syntax is supported yet, in particular with the 'NULL' or
+'None' parameters.
+************ glXSwapBuffers
+OK.
+************ glXWaitGL / glXWaitX
+Ignored.
+See README.BEOS for BeOS limitations.

/programs/develop/libraries/TinyGL/Makefile
0,0 → 1,7

all:
make -C src


clean:
make -C src clean

 /programs/develop/libraries/TinyGL/README
 ,0 → 1,150
+TinyGL 0.4 (c) 1997-2002 Fabrice Bellard.
+General Description:
+--------------------
+TinyGL is intended to be a very small implementation of a subset of
+OpenGL* for embedded systems or games. It is a software only
+implementation. Only the main OpenGL calls are implemented. All the
+calls I considered not important are simply *not implemented*.
+The main strength of TinyGL is that it is fast and simple because it
+has not to be exactly compatible with OpenGL. In particular, the
+texture mapping and the geometrical transformations are very fast.
+The main features of TinyGL are:
+- Header compatible with OpenGL (the headers are adapted from the very good
+Mesa by Brian Paul et al.)
+- Zlib-like licence for easy integration in commercial designs (read
+the LICENCE file).
+- Subset of GLX for easy testing with X Window.
+- GLX like API (NGLX) to use it with NanoX in MicroWindows/NanoX.
+- Subset of BGLView under BeOS.
+- OpenGL like lightening.
+- Complete OpenGL selection mode handling for object picking.
+- 16 bit Z buffer. 16/24/32 bit RGB rendering. High speed dithering to
+paletted 8 bits if needed. High speed conversion to 24 bit packed
+pixel or 32 bit RGBA if needed.
+- Fast Gouraud shadding optimized for 16 bit RGB.
+- Fast texture mapping capabilities, with perspective correction and
+texture objects.
+- 32 bit float only arithmetic.
+- Very small: compiled code size of about 40 kB on x86. The file
+  src/zfeatures.h can be used to remove some unused features from
+  TinyGL.
+- C sources for GCC on 32/64 bit architectures. It has been tested
+succesfully on x86-Linux and sparc-Solaris.
+Examples:
+---------
+I took three simple examples from the Mesa package to test the main
+functions of TinyGL. You can link them to either TinyGL, Mesa or any
+other OpenGL/GLX implementation. You can also compile them with
+Microwindows.
+- texobj illustrates the use of texture objects. Its shows the speed
+of TinyGL in this case.
+- glutmech comes from the GLUT packages. It is much bigger and slower
+because it uses the lightening. I have just included some GLU
+functions and suppressed the GLUT related code to make it work. It
+shows the display list handling of TinyGL in particular. You can look
+at the source code to learn the keys to move the robot. The key 't'
+toggles between shaded rendering and wire frame.
+- You can download and compile the VReng project to see that TinyGL
+has been successfully used in a big project
+(http://www-inf.enst.fr/vreng).
+Architecture:
+-------------
+TinyGL is made up four main modules:
+- Mathematical routines (zmath).
+- OpenGL-like emulation (zgl).
+- Z buffer and rasterisation (zbuffer).
+- GLX interface (zglx).
+To use TinyGL in an embedded system, you should look at the GLX layer
+and modify it to suit your need. Adding a more user friendly
+developper layer (as in Mesa) may be useful.
+Notes - limitations:
+--------------------
+- See the file 'LIMITATIONS' to see the current functions supported by the API.
+- The multithreading could be easily implemented since no global state
+is maintainted. The library gets the current context with a function
+which can be modified.
+- The lightening is not very fast. I supposed that in most games the
+lightening is computed by the 3D engine.
+- Some changes are needed for 64 bit pointers for the handling of
+arrays of float with the GLParam union.
+- List sharing is partialy supported in the source, but not by the
+current TinyGLX implementation (is it really useful ?).
+- No user clipping planes are supported.
+- No color index mode (no longer useful !)
+- The mipmapping is not implemented.
+- The perspecture correction in the mapping code does not use W but
+/Z. In any 'normal scene' it should work.
+- The resizing of the viewport in TinyGLX ensures that the width and
+the height are multiples of 4. This is not optimal because some pixels
+of the window may not be refreshed.
+Why ?
+-----
+TinyGL was developped as a student project for a Virtual Reality
+network system called VReng (see the VReng home page at
+http://www-inf.enst.fr/vreng).
+At that time (January 1997), my initial project was to write my own 3D
+rasterizer based on some old sources I wrote. But I realized that it
+would be better to use OpenGL to work on any platform. My problem was
+that I wanted to use texture mapping which was (and is still) quite
+slower on many software OpenGL implementation. I could have modified
+Mesa to suit my needs, but I really wanted to use my old sources for
+that project.
+I finally decided to use the same syntax as OpenGL but with my own
+libraries, thinking that later it could ease the porting of VReng to
+OpenGL.
+Now VReng is at last compatible with OpenGL, and I managed to patch
+TinyGL so that VReng can still work with it without any modifications.
+Since TinyGL may be useful for some people, especially in the world of
+embedded designs, I decided to release it 'as is', otherwise, it would
+have been lost on my hard disk !
+------------------------------------------------------------------------------
+* OpenGL(R) is a registered trademark of Silicon Graphics, Inc.
+------------------------------------------------------------------------------
+Fabrice Bellard.

/programs/develop/libraries/TinyGL/config.mk
0,0 → 1,7
#####################################################################
# C compiler

CC= gcc
CFLAGS= -c -nodefaultlibs -mmmx -mtune=pentiumpro -O2 -w

 /programs/develop/libraries/TinyGL/examples/Makefile
 ,0 → 1,29
+include ../config.mk
+PROGS = mech texobj gears spin
+all: $(PROGS)
+clean:
+        rm -f core *.o *~ $(PROGS)
+mech: mech.o glu.o $(UI_OBJS) $(GL_DEPS)
+        $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+texobj: texobj.o $(UI_OBJS) $(GL_DEPS)
+        $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+gears: gears.o $(UI_OBJS) $(GL_DEPS)
+        $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+spin: spin.o $(UI_OBJS) $(GL_DEPS)
+        $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+.c.o:
+        $(CC)   $(CFLAGS) $(GL_INCLUDES) $(UI_INCLUDES) -c $*.c
+mech.o: glu.h
+glu.o: glu.h
+ui.o: ui.h

 /programs/develop/libraries/TinyGL/examples/gears.c
 ,0 → 1,300
+/* gears.c */
+/*
+ * 3-D gear wheels.  This program is in the public domain.
+ *
+ * Brian Paul
+ */
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include "ui.h"
+#ifndef M_PI
+#  define M_PI 3.14159265
+#endif
+/*
+ * Draw a gear wheel.  You'll probably want to call this function when
+ * building a display list since we do a lot of trig here.
+ *
+ * Input:  inner_radius - radius of hole at center
+ *         outer_radius - radius at center of teeth
+ *         width - width of gear
+ *         teeth - number of teeth
+ *         tooth_depth - depth of tooth
+ */
+static void gear( GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
+                  GLint teeth, GLfloat tooth_depth )
+{
+   GLint i;
+   GLfloat r0, r1, r2;
+   GLfloat angle, da;
+   GLfloat u, v, len;
+   r0 = inner_radius;
+   r1 = outer_radius - tooth_depth/2.0;
+   r2 = outer_radius + tooth_depth/2.0;
+   da = 2.0*M_PI / teeth / 4.0;
+   glShadeModel( GL_FLAT );
+   glNormal3f( 0.0, 0.0, 1.0 );
+   /* draw front face */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<=teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 );
+      glVertex3f( r1*cos(angle), r1*sin(angle), width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 );
+   }
+   glEnd();
+   /* draw front sides of teeth */
+   glBegin( GL_QUADS );
+   da = 2.0*M_PI / teeth / 4.0;
+   for (i=0;i<teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glVertex3f( r1*cos(angle),      r1*sin(angle),      width*0.5 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),   width*0.5 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 );
+   }
+   glEnd();
+   glNormal3f( 0.0, 0.0, -1.0 );
+   /* draw back face */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<=teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glVertex3f( r1*cos(angle), r1*sin(angle), -width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 );
+   }
+   glEnd();
+   /* draw back sides of teeth */
+   glBegin( GL_QUADS );
+   da = 2.0*M_PI / teeth / 4.0;
+   for (i=0;i<teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),   -width*0.5 );
+      glVertex3f( r1*cos(angle),      r1*sin(angle),      -width*0.5 );
+   }
+   glEnd();
+   /* draw outward faces of teeth */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glVertex3f( r1*cos(angle),      r1*sin(angle),       width*0.5 );
+      glVertex3f( r1*cos(angle),      r1*sin(angle),      -width*0.5 );
+      u = r2*cos(angle+da) - r1*cos(angle);
+      v = r2*sin(angle+da) - r1*sin(angle);
+      len = sqrt( u*u + v*v );
+      u /= len;
+      v /= len;
+      glNormal3f( v, -u, 0.0 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),    width*0.5 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),   -width*0.5 );
+      glNormal3f( cos(angle), sin(angle), 0.0 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da),  width*0.5 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5 );
+      u = r1*cos(angle+3*da) - r2*cos(angle+2*da);
+      v = r1*sin(angle+3*da) - r2*sin(angle+2*da);
+      glNormal3f( v, -u, 0.0 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da),  width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 );
+      glNormal3f( cos(angle), sin(angle), 0.0 );
+   }
+   glVertex3f( r1*cos(0), r1*sin(0), width*0.5 );
+   glVertex3f( r1*cos(0), r1*sin(0), -width*0.5 );
+   glEnd();
+   glShadeModel( GL_SMOOTH );
+   /* draw inside radius cylinder */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<=teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glNormal3f( -cos(angle), -sin(angle), 0.0 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 );
+   }
+   glEnd();
+}
+static GLfloat view_rotx=20.0, view_roty=30.0, view_rotz=0.0;
+static GLint gear1, gear2, gear3;
+static GLfloat angle = 0.0;
+static GLuint limit;
+static GLuint count = 1;
+void draw( void )
+{
+   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+   glPushMatrix();
+   glRotatef( view_rotx, 1.0, 0.0, 0.0 );
+   glRotatef( view_roty, 0.0, 1.0, 0.0 );
+   glRotatef( view_rotz, 0.0, 0.0, 1.0 );
+   glPushMatrix();
+   glTranslatef( -3.0, -2.0, 0.0 );
+   glRotatef( angle, 0.0, 0.0, 1.0 );
+   glCallList(gear1);
+   glPopMatrix();
+   glPushMatrix();
+   glTranslatef( 3.1, -2.0, 0.0 );
+   glRotatef( -2.0*angle-9.0, 0.0, 0.0, 1.0 );
+   glCallList(gear2);
+   glPopMatrix();
+   glPushMatrix();
+   glTranslatef( -3.1, 4.2, 0.0 );
+   glRotatef( -2.0*angle-25.0, 0.0, 0.0, 1.0 );
+   glCallList(gear3);
+   glPopMatrix();
+   glPopMatrix();
+   tkSwapBuffers();
+   count++;
+   if (count==limit) {
+       exit(0);
+   }
+}
+void idle( void )
+{
+   angle += 2.0;
+   draw();
+}
+/* change view angle, exit upon ESC */
+GLenum key(int k, GLenum mask)
+{
+   switch (k) {
+      case KEY_UP:
+         view_rotx += 5.0;
+         return GL_TRUE;
+      case KEY_DOWN:
+         view_rotx -= 5.0;
+         return GL_TRUE;
+      case KEY_LEFT:
+         view_roty += 5.0;
+         return GL_TRUE;
+      case KEY_RIGHT:
+         view_roty -= 5.0;
+         return GL_TRUE;
+      case 'z':
+         view_rotz += 5.0;
+         return GL_TRUE;
+      case 'Z':
+         view_rotz -= 5.0;
+         return GL_TRUE;
+      case KEY_ESCAPE:
+          exit(0);
+   }
+   return GL_FALSE;
+}
+/* new window size or exposure */
+void reshape( int width, int height )
+{
+   GLfloat  h = (GLfloat) height / (GLfloat) width;
+   glViewport(0, 0, (GLint)width, (GLint)height);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glFrustum( -1.0, 1.0, -h, h, 5.0, 60.0 );
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+   glTranslatef( 0.0, 0.0, -40.0 );
+   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+}
+void init( void )
+{
+   static GLfloat pos[4] = {5.0, 5.0, 10.0, 0.0 };
+   static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0 };
+   static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0 };
+   static GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0 };
+   glLightfv( GL_LIGHT0, GL_POSITION, pos );
+   glEnable( GL_CULL_FACE );
+   glEnable( GL_LIGHTING );
+   glEnable( GL_LIGHT0 );
+   glEnable( GL_DEPTH_TEST );
+   /* make the gears */
+   gear1 = glGenLists(1);
+   glNewList(gear1, GL_COMPILE);
+   glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red );
+   gear( 1.0, 4.0, 1.0, 20, 0.7 );
+   glEndList();
+   gear2 = glGenLists(1);
+   glNewList(gear2, GL_COMPILE);
+   glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green );
+   gear( 0.5, 2.0, 2.0, 10, 0.7 );
+   glEndList();
+   gear3 = glGenLists(1);
+   glNewList(gear3, GL_COMPILE);
+   glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue );
+   gear( 1.3, 2.0, 0.5, 10, 0.7 );
+   glEndList();
+   glEnable( GL_NORMALIZE );
+}
+int main(int argc, char **argv)
+{
+   if (argc>1) {
+      /* do 'n' frames then exit */
+      limit = atoi( argv[1] ) + 1;
+   }
+   else {
+      limit = 0;
+   }
+   return ui_loop(argc, argv, "gears");
+}

 /programs/develop/libraries/TinyGL/examples/glu.c
 ,0 → 1,261
+#include <stdlib.h>
+#include <math.h>
+#include <GL/gl.h>
+#include "glu.h"
+void drawTorus(float rc, int numc, float rt, int numt)
+{
+    int i, j, k;
+    double s, t;
+    double x, y, z;
+    double pi, twopi;
+    pi = 3.14159265358979323846;
+    twopi = 2 * pi;
+    for (i = 0; i < numc; i++) {
+        glBegin(GL_QUAD_STRIP);
+        for (j = 0; j <= numt; j++) {
+            for (k = 1; k >= 0; k--) {
+                s = (i + k) % numc + 0.5;
+                t = j % numt;
+                x = cos(t*twopi/numt) * cos(s*twopi/numc);
+                y = sin(t*twopi/numt) * cos(s*twopi/numc);
+                z = sin(s*twopi/numc);
+                glNormal3f(x, y, z);
+                x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt);
+                y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt);
+                z = rc * sin(s*twopi/numc);
+                glVertex3f(x, y, z);
+            }
+        }
+        glEnd();
+    }
+}
+static void normal3f( GLfloat x, GLfloat y, GLfloat z )
+{
+   GLdouble mag;
+   mag = sqrt( x*x + y*y + z*z );
+   if (mag>0.00001F) {
+      x /= mag;
+      y /= mag;
+      z /= mag;
+   }
+   glNormal3f( x, y, z );
+}
+void gluPerspective( GLdouble fovy, GLdouble aspect,
+                     GLdouble zNear, GLdouble zFar )
+{
+   GLdouble xmin, xmax, ymin, ymax;
+   ymax = zNear * tan( fovy * M_PI / 360.0 );
+   ymin = -ymax;
+   xmin = ymin * aspect;
+   xmax = ymax * aspect;
+   glFrustum( xmin, xmax, ymin, ymax, zNear, zFar );
+}
+GLUquadricObj *gluNewQuadric(void)
+{
+  return NULL;
+}
+void gluQuadricDrawStyle(GLUquadricObj *obj, int style)
+{
+}
+void gluCylinder( GLUquadricObj *qobj,
+                  GLdouble baseRadius, GLdouble topRadius, GLdouble height,
+                  GLint slices, GLint stacks )
+{
+   GLdouble da, r, dr, dz;
+   GLfloat z, nz, nsign;
+   GLint i, j;
+   GLfloat du = 1.0 / slices;
+   GLfloat dv = 1.0 / stacks;
+   GLfloat tcx = 0.0, tcy = 0.0;
+   nsign = 1.0;
+   da = 2.0*M_PI / slices;
+   dr = (topRadius-baseRadius) / stacks;
+   dz = height / stacks;
+   nz = (baseRadius-topRadius) / height;  /* Z component of normal vectors */
+   for (i=0;i<slices;i++) {
+         GLfloat x1 = -sin(i*da);
+         GLfloat y1 = cos(i*da);
+         GLfloat x2 = -sin((i+1)*da);
+         GLfloat y2 = cos((i+1)*da);
+         z = 0.0;
+         r = baseRadius;
+         tcy = 0.0;
+         glBegin( GL_QUAD_STRIP );
+         for (j=0;j<=stacks;j++) {
+            if (nsign==1.0) {
+               normal3f( x1*nsign, y1*nsign, nz*nsign );
+               glTexCoord2f(tcx, tcy);
+               glVertex3f( x1*r, y1*r, z );
+               normal3f( x2*nsign, y2*nsign, nz*nsign );
+               glTexCoord2f(tcx+du, tcy);
+               glVertex3f( x2*r, y2*r, z );
+            }
+            else {
+               normal3f( x2*nsign, y2*nsign, nz*nsign );
+               glTexCoord2f(tcx, tcy);
+               glVertex3f( x2*r, y2*r, z );
+               normal3f( x1*nsign, y1*nsign, nz*nsign );
+               glTexCoord2f(tcx+du, tcy);
+               glVertex3f( x1*r, y1*r, z );
+            }
+            z += dz;
+            r += dr;
+            tcy += dv;
+         }
+         glEnd();
+         tcx += du;
+      }
+}
+/* Disk (adapted from Mesa) */
+void gluDisk( GLUquadricObj *qobj,
+              GLdouble innerRadius, GLdouble outerRadius,
+              GLint slices, GLint loops )
+{
+   GLdouble a, da;
+   GLfloat dr;
+   GLfloat r1, r2, dtc;
+   GLint s, l;
+   GLfloat sa,ca;
+   /* Normal vectors */
+         glNormal3f( 0.0, 0.0, +1.0 );
+   da = 2.0*M_PI / slices;
+   dr = (outerRadius-innerRadius) / (GLfloat) loops;
+   /* texture of a gluDisk is a cut out of the texture unit square */
+   /* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */
+   dtc = 2.0f * outerRadius;
+   r1 = innerRadius;
+   for (l=0;l<loops;l++) {
+            r2 = r1 + dr;
+               glBegin( GL_QUAD_STRIP );
+               for (s=0;s<=slices;s++) {
+                  if (s==slices) a = 0.0;
+                  else  a = s * da;
+                  sa = sin(a); ca = cos(a);
+                  glTexCoord2f(0.5+sa*r2/dtc,0.5+ca*r2/dtc);
+                  glVertex2f( r2*sa, r2*ca );
+                  glTexCoord2f(0.5+sa*r1/dtc,0.5+ca*r1/dtc);
+                  glVertex2f( r1*sa, r1*ca );
+               }
+               glEnd();
+            r1 = r2;
+         }
+}
+/*
+ * Sphère (adapted from Mesa)
+ */
+void gluSphere(GLUquadricObj *qobj,
+               float radius,int slices,int stacks)
+{
+   float rho, drho, theta, dtheta;
+   float x, y, z;
+   float s, t, ds, dt;
+   int i, j, imin, imax;
+   int normals;
+   float nsign;
+   normals=1;
+   nsign=1;
+   drho = M_PI / (float) stacks;
+   dtheta = 2.0 * M_PI / (float) slices;
+  /* draw +Z end as a triangle fan */
+  glBegin( GL_TRIANGLE_FAN );
+  glNormal3f( 0.0, 0.0, 1.0 );
+  glTexCoord2f(0.5,0.0);
+  glVertex3f( 0.0, 0.0, nsign * radius );
+  for (j=0;j<=slices;j++) {
+         theta = (j==slices) ? 0.0 : j * dtheta;
+         x = -sin(theta) * sin(drho);
+         y = cos(theta) * sin(drho);
+         z = nsign * cos(drho);
+         if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+         glVertex3f( x*radius, y*radius, z*radius );
+      }
+   glEnd();
+      ds = 1.0 / slices;
+      dt = 1.0 / stacks;
+      t = 1.0;  /* because loop now runs from 0 */
+      if (1) {
+        imin = 0;
+        imax = stacks;
+      }
+      else {
+        imin = 1;
+        imax = stacks-1;
+      }
+      /* draw intermediate stacks as quad strips */
+      for (i=imin;i<imax;i++) {
+         rho = i * drho;
+         glBegin( GL_QUAD_STRIP );
+         s = 0.0;
+         for (j=0;j<=slices;j++) {
+            theta = (j==slices) ? 0.0 : j * dtheta;
+            x = -sin(theta) * sin(rho);
+            y = cos(theta) * sin(rho);
+            z = nsign * cos(rho);
+            if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+            glTexCoord2f(s,1-t);
+            glVertex3f( x*radius, y*radius, z*radius );
+            x = -sin(theta) * sin(rho+drho);
+            y = cos(theta) * sin(rho+drho);
+            z = nsign * cos(rho+drho);
+            if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+            glTexCoord2f(s,1-(t-dt));
+            s += ds;
+            glVertex3f( x*radius, y*radius, z*radius );
+         }
+         glEnd();
+         t -= dt;
+      }
+/* draw -Z end as a triangle fan */
+    glBegin( GL_TRIANGLE_FAN );
+    glNormal3f( 0.0, 0.0, -1.0 );
+      glTexCoord2f(0.5,1.0);
+      glVertex3f( 0.0, 0.0, -radius*nsign );
+      rho = M_PI - drho;
+      s = 1.0;
+      t = dt;
+      for (j=slices;j>=0;j--) {
+         theta = (j==slices) ? 0.0 : j * dtheta;
+         x = -sin(theta) * sin(rho);
+         y = cos(theta) * sin(rho);
+         z = nsign * cos(rho);
+         if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+         glTexCoord2f(s,1-t);
+         s -= ds;
+         glVertex3f( x*radius, y*radius, z*radius );
+      }
+      glEnd();
+}

 /programs/develop/libraries/TinyGL/examples/glu.h
 ,0 → 1,23
+void gluPerspective( GLdouble fovy, GLdouble aspect,
+                     GLdouble zNear, GLdouble zFar );
+typedef struct {
+  int draw_style;
+} GLUquadricObj;
+#define GLU_LINE 0
+GLUquadricObj *gluNewQuadric(void);
+void gluQuadricDrawStyle(GLUquadricObj *obj, int style);
+void gluSphere(GLUquadricObj *qobj,
+               float radius,int slices,int stacks);
+void gluCylinder( GLUquadricObj *qobj,
+                  GLdouble baseRadius, GLdouble topRadius, GLdouble height,
+                  GLint slices, GLint stacks );
+void gluDisk( GLUquadricObj *qobj,
+              GLdouble innerRadius, GLdouble outerRadius,
+              GLint slices, GLint loops );
+void drawTorus(float rc, int numc, float rt, int numt);

 /programs/develop/libraries/TinyGL/examples/mech.c
 ,0 → 1,1753
+/**
+* program       : glutmech V1.1
+* author        : Simon Parkinson-Bates.
+* E-mail        : sapb@yallara.cs.rmit.edu.au
+* Copyright Simon Parkinson-Bates.
+* "source if freely avaliable to anyone to copy as long as they
+*  acknowledge me in their work."
+*
+* Funtional features
+* ------------------
+* * online menu system avaliable by pressing left mouse button
+* * online cascading help system avaliable, providing information on
+*       the several  key strokes and what they do.
+* * animation sequence coded which makes the mech walk through an
+*       environment.  Shadows will soon be added to make it look
+*       more realistic.
+* * menu control to view mech in wireframe or sold mode.
+* * various key strokes avaliable to control idependently the mechs
+*       many joints.
+* * various key strokes avaliable to view mech and environment from
+*       different angles
+* * various key strokes avaliable to alter positioning of the single
+*       light source.
+*
+*
+* Program features
+* ----------------
+* * uses double buffering
+* * uses display lists
+* * uses glut to manage windows, callbacks, and online menu.
+* * uses glpolygonfill() to maintain colors in wireframe and solid
+*       mode.
+*
+**/
+/* start of compilation conditions */
+#define SPHERE
+#define COLOR
+#define LIGHT
+#define TORSO
+#define HIP
+#define SHOULDER
+#define UPPER_ARM
+#define LOWER_ARM
+#define ROCKET_POD
+#define UPPER_LEG
+#define LOWER_LEG
+#define NO_NORM
+#define ANIMATION
+#define DRAW_MECH
+#define DRAW_ENVIRO
+#define MOVE_LIGHT
+/* end of compilation conditions */
+/* start various header files needed */
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#define GLUT
+#define GLUT_KEY
+#define GLUT_SPEC
+#include <GL/gl.h>
+#include <GL/glx.h>
+#include "glu.h"
+#include "ui.h"
+/* end of header files */
+/* start of display list definitions */
+#define SOLID_MECH_TORSO        1
+#define SOLID_MECH_HIP          2
+#define SOLID_MECH_SHOULDER     3
+#define SOLID_MECH_UPPER_ARM    4
+#define SOLID_MECH_FOREARM      5
+#define SOLID_MECH_UPPER_LEG    6
+#define SOLID_MECH_FOOT         7
+#define SOLID_MECH_ROCKET       8
+#define SOLID_MECH_VULCAN       9
+#define SOLID_ENVIRO            10
+/* end of display list definitions */
+/* start of motion rate variables */
+#define ANKLE_RATE      3
+#define HEEL_RATE       3
+#define ROTATE_RATE     10
+#define TILT_RATE       10
+#define ELBOW_RATE      2
+#define SHOULDER_RATE   5
+#define LAT_RATE        5
+#define CANNON_RATE     40
+#define UPPER_LEG_RATE  3
+#define UPPER_LEG_RATE_GROIN 10
+#define LIGHT_TURN_RATE 10
+#define VIEW_TURN_RATE  10
+/* end of motion rate variables */
+/* start of motion  variables */
+#ifndef PI
+#define PI 3.141592654
+#endif
+char leg = 0;
+int shoulder1 = 0, shoulder2 = 0, shoulder3 = 0, shoulder4 = 0, lat1 = 20, lat2 = 20,
+  elbow1 = 0, elbow2 = 0, pivot = 0, tilt = 10, ankle1 = 0, ankle2 = 0, heel1 = 0,
+  heel2 = 0, hip11 = 0, hip12 = 10, hip21 = 0, hip22 = 10, fire = 0, solid_part = 0,
+  anim = 0, turn = 0, turn1 = 0, lightturn = 0, lightturn1 = 0;
+float elevation = 0.0, distance = 0.0, frame = 3.0
+ /* foot1v[] = {} foot2v[] = {} */ ;
+/* end of motion variables */
+/* start of material definitions */
+#ifdef LIGHT
+GLfloat mat_specular[] =
+{0.628281, 0.555802, 0.366065, 1.0};
+GLfloat mat_ambient[] =
+{0.24725, 0.1995, 0.0745, 1.0};
+GLfloat mat_diffuse[] =
+{0.75164, 0.60648, 0.22648, 1.0};
+GLfloat mat_shininess[] =
+{128.0 * 0.4};
+GLfloat mat_specular2[] =
+{0.508273, 0.508273, 0.508373, 1.0};
+GLfloat mat_ambient2[] =
+{0.19225, 0.19225, 0.19225, 1.0};
+GLfloat mat_diffuse2[] =
+{0.50754, 0.50754, 0.50754, 1.0};
+GLfloat mat_shininess2[] =
+{128.0 * 0.6};
+GLfloat mat_specular3[] =
+{0.296648, 0.296648, 0.296648, 1.0};
+GLfloat mat_ambient3[] =
+{0.25, 0.20725, 0.20725, 1.0};
+GLfloat mat_diffuse3[] =
+{1, 0.829, 0.829, 1.0};
+GLfloat mat_shininess3[] =
+{128.0 * 0.088};
+GLfloat mat_specular4[] =
+{0.633, 0.727811, 0.633, 1.0};
+GLfloat mat_ambient4[] =
+{0.0215, 0.1745, 0.0215, 1.0};
+GLfloat mat_diffuse4[] =
+{0.07568, 0.61424, 0.07568, 1.0};
+GLfloat mat_shininess4[] =
+{128 * 0.6};
+GLfloat mat_specular5[] =
+{0.60, 0.60, 0.50, 1.0};
+GLfloat mat_ambient5[] =
+{0.0, 0.0, 0.0, 1.0};
+GLfloat mat_diffuse5[] =
+{0.5, 0.5, 0.0, 1.0};
+GLfloat mat_shininess5[] =
+{128.0 * 0.25};
+#endif
+/* end of material definitions */
+/* start of the body motion functions */
+void
+Heel1Add(void)
+{
+  heel1 = (heel1 + HEEL_RATE) % 360;
+}
+void
+Heel1Subtract(void)
+{
+  heel1 = (heel1 - HEEL_RATE) % 360;
+}
+void
+Heel2Add(void)
+{
+  heel2 = (heel2 + HEEL_RATE) % 360;
+}
+void
+Heel2Subtract(void)
+{
+  heel2 = (heel2 - HEEL_RATE) % 360;
+}
+void
+Ankle1Add(void)
+{
+  ankle1 = (ankle1 + ANKLE_RATE) % 360;
+}
+void
+Ankle1Subtract(void)
+{
+  ankle1 = (ankle1 - ANKLE_RATE) % 360;
+}
+void
+Ankle2Add(void)
+{
+  ankle2 = (ankle2 + ANKLE_RATE) % 360;
+}
+void
+Ankle2Subtract(void)
+{
+  ankle2 = (ankle2 - ANKLE_RATE) % 360;
+}
+void
+RotateAdd(void)
+{
+  pivot = (pivot + ROTATE_RATE) % 360;
+}
+void
+RotateSubtract(void)
+{
+  pivot = (pivot - ROTATE_RATE) % 360;
+}
+void
+MechTiltSubtract(void)
+{
+  tilt = (tilt - TILT_RATE) % 360;
+}
+void
+MechTiltAdd(void)
+{
+  tilt = (tilt + TILT_RATE) % 360;
+}
+void
+elbow1Add(void)
+{
+  elbow1 = (elbow1 + ELBOW_RATE) % 360;
+}
+void
+elbow1Subtract(void)
+{
+  elbow1 = (elbow1 - ELBOW_RATE) % 360;
+}
+void
+elbow2Add(void)
+{
+  elbow2 = (elbow2 + ELBOW_RATE) % 360;
+}
+void
+elbow2Subtract(void)
+{
+  elbow2 = (elbow2 - ELBOW_RATE) % 360;
+}
+void
+shoulder1Add(void)
+{
+  shoulder1 = (shoulder1 + SHOULDER_RATE) % 360;
+}
+void
+shoulder1Subtract(void)
+{
+  shoulder1 = (shoulder1 - SHOULDER_RATE) % 360;
+}
+void
+shoulder2Add(void)
+{
+  shoulder2 = (shoulder2 + SHOULDER_RATE) % 360;
+}
+void
+shoulder2Subtract(void)
+{
+  shoulder2 = (shoulder2 - SHOULDER_RATE) % 360;
+}
+void
+shoulder3Add(void)
+{
+  shoulder3 = (shoulder3 + SHOULDER_RATE) % 360;
+}
+void
+shoulder3Subtract(void)
+{
+  shoulder3 = (shoulder3 - SHOULDER_RATE) % 360;
+}
+void
+shoulder4Add(void)
+{
+  shoulder4 = (shoulder4 + SHOULDER_RATE) % 360;
+}
+void
+shoulder4Subtract(void)
+{
+  shoulder4 = (shoulder4 - SHOULDER_RATE) % 360;
+}
+void
+lat1Raise(void)
+{
+  lat1 = (lat1 + LAT_RATE) % 360;
+}
+void
+lat1Lower(void)
+{
+  lat1 = (lat1 - LAT_RATE) % 360;
+}
+void
+lat2Raise(void)
+{
+  lat2 = (lat2 + LAT_RATE) % 360;
+}
+void
+lat2Lower(void)
+{
+  lat2 = (lat2 - LAT_RATE) % 360;
+}
+void
+FireCannon(void)
+{
+  fire = (fire + CANNON_RATE) % 360;
+}
+void
+RaiseLeg1Forward(void)
+{
+  hip11 = (hip11 + UPPER_LEG_RATE) % 360;
+}
+void
+LowerLeg1Backwards(void)
+{
+  hip11 = (hip11 - UPPER_LEG_RATE) % 360;
+}
+void
+RaiseLeg1Outwards(void)
+{
+  hip12 = (hip12 + UPPER_LEG_RATE_GROIN) % 360;
+}
+void
+LowerLeg1Inwards(void)
+{
+  hip12 = (hip12 - UPPER_LEG_RATE_GROIN) % 360;
+}
+void
+RaiseLeg2Forward(void)
+{
+  hip21 = (hip21 + UPPER_LEG_RATE) % 360;
+}
+void
+LowerLeg2Backwards(void)
+{
+  hip21 = (hip21 - UPPER_LEG_RATE) % 360;
+}
+void
+RaiseLeg2Outwards(void)
+{
+  hip22 = (hip22 + UPPER_LEG_RATE_GROIN) % 360;
+}
+void
+LowerLeg2Inwards(void)
+{
+  hip22 = (hip22 - UPPER_LEG_RATE_GROIN) % 360;
+}
+/* end of body motion functions */
+/* start of light source position functions */
+void
+TurnRight(void)
+{
+  turn = (turn - VIEW_TURN_RATE) % 360;
+}
+void
+TurnLeft(void)
+{
+  turn = (turn + VIEW_TURN_RATE) % 360;
+}
+void
+TurnForwards(void)
+{
+  turn1 = (turn1 - VIEW_TURN_RATE) % 360;
+}
+void
+TurnBackwards(void)
+{
+  turn1 = (turn1 + VIEW_TURN_RATE) % 360;
+}
+void
+LightTurnRight(void)
+{
+  lightturn = (lightturn + LIGHT_TURN_RATE) % 360;
+}
+void
+LightTurnLeft(void)
+{
+  lightturn = (lightturn - LIGHT_TURN_RATE) % 360;
+}
+void
+LightForwards(void)
+{
+  lightturn1 = (lightturn1 + LIGHT_TURN_RATE) % 360;
+}
+void
+LightBackwards(void)
+{
+  lightturn1 = (lightturn1 - LIGHT_TURN_RATE) % 360;
+}
+/* end of light source position functions */
+/* start of geometric shape functions */
+void
+Box(float width, float height, float depth, char solid)
+{
+  char i, j = 0;
+  float x = width / 2.0, y = height / 2.0, z = depth / 2.0;
+  for (i = 0; i < 4; i++) {
+    glRotatef(90.0, 0.0, 0.0, 1.0);
+    if (j) {
+      if (!solid)
+        glBegin(GL_LINE_LOOP);
+      else
+        glBegin(GL_QUADS);
+      glNormal3f(-1.0, 0.0, 0.0);
+      glVertex3f(-x, y, z);
+      glVertex3f(-x, -y, z);
+      glVertex3f(-x, -y, -z);
+      glVertex3f(-x, y, -z);
+      glEnd();
+      if (solid) {
+        glBegin(GL_TRIANGLES);
+        glNormal3f(0.0, 0.0, 1.0);
+        glVertex3f(0.0, 0.0, z);
+        glVertex3f(-x, y, z);
+        glVertex3f(-x, -y, z);
+        glNormal3f(0.0, 0.0, -1.0);
+        glVertex3f(0.0, 0.0, -z);
+        glVertex3f(-x, -y, -z);
+        glVertex3f(-x, y, -z);
+        glEnd();
+      }
+      j = 0;
+    } else {
+      if (!solid)
+        glBegin(GL_LINE_LOOP);
+      else
+        glBegin(GL_QUADS);
+      glNormal3f(-1.0, 0.0, 0.0);
+      glVertex3f(-y, x, z);
+      glVertex3f(-y, -x, z);
+      glVertex3f(-y, -x, -z);
+      glVertex3f(-y, x, -z);
+      glEnd();
+      if (solid) {
+        glBegin(GL_TRIANGLES);
+        glNormal3f(0.0, 0.0, 1.0);
+        glVertex3f(0.0, 0.0, z);
+        glVertex3f(-y, x, z);
+        glVertex3f(-y, -x, z);
+        glNormal3f(0.0, 0.0, -1.0);
+        glVertex3f(0.0, 0.0, -z);
+        glVertex3f(-y, -x, -z);
+        glVertex3f(-y, x, -z);
+        glEnd();
+      }
+      j = 1;
+    }
+  }
+}
+void
+Octagon(float side, float height, char solid)
+{
+  char j;
+  float x = sin(0.785398163) * side, y = side / 2.0, z = height / 2.0, c;
+  c = x + y;
+  for (j = 0; j < 8; j++) {
+    glTranslatef(-c, 0.0, 0.0);
+    if (!solid)
+      glBegin(GL_LINE_LOOP);
+    else
+      glBegin(GL_QUADS);
+    glNormal3f(-1.0, 0.0, 0.0);
+    glVertex3f(0.0, -y, z);
+    glVertex3f(0.0, y, z);
+    glVertex3f(0.0, y, -z);
+    glVertex3f(0.0, -y, -z);
+    glEnd();
+    glTranslatef(c, 0.0, 0.0);
+    if (solid) {
+      glBegin(GL_TRIANGLES);
+      glNormal3f(0.0, 0.0, 1.0);
+      glVertex3f(0.0, 0.0, z);
+      glVertex3f(-c, -y, z);
+      glVertex3f(-c, y, z);
+      glNormal3f(0.0, 0.0, -1.0);
+      glVertex3f(0.0, 0.0, -z);
+      glVertex3f(-c, y, -z);
+      glVertex3f(-c, -y, -z);
+      glEnd();
+    }
+    glRotatef(45.0, 0.0, 0.0, 1.0);
+  }
+}
+/* end of geometric shape functions */
+#ifdef NORM
+void
+Normalize(float v[3])
+{
+  GLfloat d = sqrt(v[1] * v[1] + v[2] * v[2] + v[3] * v[3]);
+  if (d == 0.0) {
+    printf("zero length vector");
+    return;
+  }
+  v[1] /= d;
+  v[2] /= d;
+  v[3] /= d;
+}
+void
+NormXprod(float v1[3], float v2[3], float v[3], float out[3])
+{
+  GLint i, j;
+  GLfloat length;
+  out[0] = v1[1] * v2[2] - v1[2] * v2[1];
+  out[1] = v1[2] * v2[0] - v1[0] * v2[2];
+  out[2] = v1[0] * v2[1] - v1[1] * v2[0];
+  Normalize(out);
+}
+#endif
+void
+SetMaterial(GLfloat spec[], GLfloat amb[], GLfloat diff[], GLfloat shin[])
+{
+  glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
+  glMaterialfv(GL_FRONT, GL_SHININESS, shin);
+  glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
+  glMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
+}
+void
+MechTorso(char solid)
+{
+  glNewList(SOLID_MECH_TORSO, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  Box(1.0, 1.0, 3.0, solid);
+  glTranslatef(0.75, 0.0, 0.0);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+  Box(0.5, 0.6, 2.0, solid);
+  glTranslatef(-1.5, 0.0, 0.0);
+  Box(0.5, 0.6, 2.0, solid);
+  glTranslatef(0.75, 0.0, 0.0);
+  glEndList();
+}
+void
+MechHip(char solid)
+{
+  int i;
+  GLUquadricObj *hip[2];
+  glNewList(SOLID_MECH_HIP, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  Octagon(0.7, 0.5, solid);
+#ifdef SPHERE
+  for (i = 0; i < 2; i++) {
+    if (i)
+      glScalef(-1.0, 1.0, 1.0);
+    glTranslatef(1.0, 0.0, 0.0);
+    hip[i] = gluNewQuadric();
+#ifdef LIGHT
+    SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+    glColor3f(0.5, 0.5, 0.5);
+    if (!solid)
+      gluQuadricDrawStyle(hip[i], GLU_LINE);
+    gluSphere(hip[0], 0.2, 16, 16);
+    glTranslatef(-1.0, 0.0, 0.0);
+  }
+  glScalef(-1.0, 1.0, 1.0);
+#endif
+  glEndList();
+}
+void
+Shoulder(char solid)
+{
+  GLUquadricObj *deltoid = gluNewQuadric();
+  glNewList(SOLID_MECH_SHOULDER, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  Box(1.0, 0.5, 0.5, solid);
+  glTranslatef(0.9, 0.0, 0.0);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+#ifdef SPHERE
+  if (!solid)
+    gluQuadricDrawStyle(deltoid, GLU_LINE);
+  gluSphere(deltoid, 0.6, 16, 16);
+#endif
+  glTranslatef(-0.9, 0.0, 0.0);
+  glEndList();
+}
+void
+UpperArm(char solid)
+{
+  GLUquadricObj *upper = gluNewQuadric();
+  GLUquadricObj *joint[2];
+  GLUquadricObj *joint1[2];
+  int i;
+  glNewList(SOLID_MECH_UPPER_ARM, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  Box(1.0, 2.0, 1.0, solid);
+  glTranslatef(0.0, -0.95, 0.0);
+  glRotatef(90.0, 1.0, 0.0, 0.0);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+  if (!solid)
+    gluQuadricDrawStyle(upper, GLU_LINE);
+  gluCylinder(upper, 0.4, 0.4, 1.5, 16, 10);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  glRotatef(-90.0, 1.0, 0.0, 0.0);
+  glTranslatef(-0.4, -1.85, 0.0);
+  glRotatef(90.0, 0.0, 1.0, 0.0);
+  for (i = 0; i < 2; i++) {
+    joint[i] = gluNewQuadric();
+    if (!solid)
+      gluQuadricDrawStyle(joint[i], GLU_LINE);
+    if (i)
+      gluCylinder(joint[i], 0.5, 0.5, 0.8, 16, 10);
+    else
+      gluCylinder(joint[i], 0.2, 0.2, 0.8, 16, 10);
+  }
+  for (i = 0; i < 2; i++) {
+    if (i)
+      glScalef(-1.0, 1.0, 1.0);
+    joint1[i] = gluNewQuadric();
+    if (!solid)
+      gluQuadricDrawStyle(joint1[i], GLU_LINE);
+    if (i)
+      glTranslatef(0.0, 0.0, 0.8);
+    gluDisk(joint1[i], 0.2, 0.5, 16, 10);
+    if (i)
+      glTranslatef(0.0, 0.0, -0.8);
+  }
+  glScalef(-1.0, 1.0, 1.0);
+  glRotatef(-90.0, 0.0, 1.0, 0.0);
+  glTranslatef(0.4, 2.9, 0.0);
+  glEndList();
+}
+void
+VulcanGun(char solid)
+{
+  int i;
+  GLUquadricObj *Barrel[5];
+  GLUquadricObj *BarrelFace[5];
+  GLUquadricObj *Barrel2[5];
+  GLUquadricObj *Barrel3[5];
+  GLUquadricObj *BarrelFace2[5];
+  GLUquadricObj *Mount = gluNewQuadric();
+  GLUquadricObj *Mount_face = gluNewQuadric();
+  glNewList(SOLID_MECH_VULCAN, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+  if (!solid) {
+    gluQuadricDrawStyle(Mount, GLU_LINE);
+    gluQuadricDrawStyle(Mount_face, GLU_LINE);
+  }
+  gluCylinder(Mount, 0.5, 0.5, 0.5, 16, 10);
+  glTranslatef(0.0, 0.0, 0.5);
+  gluDisk(Mount_face, 0.0, 0.5, 16, 10);
+  for (i = 0; i < 5; i++) {
+    Barrel[i] = gluNewQuadric();
+    BarrelFace[i] = gluNewQuadric();
+    BarrelFace2[i] = gluNewQuadric();
+    Barrel2[i] = gluNewQuadric();
+    Barrel3[i] = gluNewQuadric();
+    glRotatef(72.0, 0.0, 0.0, 1.0);
+    glTranslatef(0.0, 0.3, 0.0);
+    if (!solid) {
+      gluQuadricDrawStyle(Barrel[i], GLU_LINE);
+      gluQuadricDrawStyle(BarrelFace[i], GLU_LINE);
+      gluQuadricDrawStyle(BarrelFace2[i], GLU_LINE);
+      gluQuadricDrawStyle(Barrel2[i], GLU_LINE);
+      gluQuadricDrawStyle(Barrel3[i], GLU_LINE);
+    }
+    gluCylinder(Barrel[i], 0.15, 0.15, 2.0, 16, 10);
+    gluCylinder(Barrel3[i], 0.06, 0.06, 2.0, 16, 10);
+    glTranslatef(0.0, 0.0, 2.0);
+    gluDisk(BarrelFace[i], 0.1, 0.15, 16, 10);
+    gluCylinder(Barrel2[i], 0.1, 0.1, 0.1, 16, 5);
+    glTranslatef(0.0, 0.0, 0.1);
+    gluDisk(BarrelFace2[i], 0.06, 0.1, 16, 5);
+    glTranslatef(0.0, -0.3, -2.1);
+  }
+  glEndList();
+}
+void
+ForeArm(char solid)
+{
+  char i;
+  glNewList(SOLID_MECH_FOREARM, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  for (i = 0; i < 5; i++) {
+    glTranslatef(0.0, -0.1, -0.15);
+    Box(0.6, 0.8, 0.2, solid);
+    glTranslatef(0.0, 0.1, -0.15);
+    Box(0.4, 0.6, 0.1, solid);
+  }
+  glTranslatef(0.0, 0.0, 2.45);
+  Box(1.0, 1.0, 2.0, solid);
+  glTranslatef(0.0, 0.0, -1.0);
+  glEndList();
+}
+void
+UpperLeg(char solid)
+{
+  int i;
+  GLUquadricObj *Hamstring = gluNewQuadric();
+  GLUquadricObj *Knee = gluNewQuadric();
+  GLUquadricObj *joint[2];
+  glNewList(SOLID_MECH_UPPER_LEG, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  if (!solid) {
+    gluQuadricDrawStyle(Hamstring, GLU_LINE);
+    gluQuadricDrawStyle(Knee, GLU_LINE);
+  }
+  glTranslatef(0.0, -1.0, 0.0);
+  Box(0.4, 1.0, 0.7, solid);
+  glTranslatef(0.0, -0.65, 0.0);
+  for (i = 0; i < 5; i++) {
+    Box(1.2, 0.3, 1.2, solid);
+    glTranslatef(0.0, -0.2, 0.0);
+    Box(1.0, 0.1, 1.0, solid);
+    glTranslatef(0.0, -0.2, 0.0);
+  }
+  glTranslatef(0.0, -0.15, -0.4);
+  Box(2.0, 0.5, 2.0, solid);
+  glTranslatef(0.0, -0.3, -0.2);
+  glRotatef(90.0, 1.0, 0.0, 0.0);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+  gluCylinder(Hamstring, 0.6, 0.6, 3.0, 16, 10);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  glRotatef(-90.0, 1.0, 0.0, 0.0);
+  glTranslatef(0.0, -1.5, 1.0);
+  Box(1.5, 3.0, 0.5, solid);
+  glTranslatef(0.0, -1.75, -0.8);
+  Box(2.0, 0.5, 2.0, solid);
+  glTranslatef(0.0, -0.9, -0.85);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+  gluCylinder(Knee, 0.8, 0.8, 1.8, 16, 10);
+  for (i = 0; i < 2; i++) {
+    if (i)
+      glScalef(-1.0, 1.0, 1.0);
+    joint[i] = gluNewQuadric();
+    if (!solid)
+      gluQuadricDrawStyle(joint[i], GLU_LINE);
+    if (i)
+      glTranslatef(0.0, 0.0, 1.8);
+    gluDisk(joint[i], 0.0, 0.8, 16, 10);
+    if (i)
+      glTranslatef(0.0, 0.0, -1.8);
+  }
+  glScalef(-1.0, 1.0, 1.0);
+  glEndList();
+}
+void
+Foot(char solid)
+{
+  glNewList(SOLID_MECH_FOOT, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+  glRotatef(90.0, 1.0, 0.0, 0.0);
+  Octagon(1.5, 0.6, solid);
+  glRotatef(-90.0, 1.0, 0.0, 0.0);
+  glEndList();
+}
+void
+LowerLeg(char solid)
+{
+  float k, l;
+  GLUquadricObj *ankle = gluNewQuadric();
+  GLUquadricObj *ankle_face[2],*joints;
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  for (k = 0.0; k < 2.0; k++) {
+    for (l = 0.0; l < 2.0; l++) {
+      glPushMatrix();
+      glTranslatef(k, 0.0, l);
+#ifdef LIGHT
+      SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+      glColor3f(1.0, 1.0, 0.0);
+      Box(1.0, 0.5, 1.0, solid);
+      glTranslatef(0.0, -0.45, 0.0);
+#ifdef LIGHT
+      SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+      glColor3f(0.5, 0.5, 0.5);
+#ifdef SPHERE
+      joints = gluNewQuadric();
+      if(!solid)gluQuadricDrawStyle(joints, GLU_LINE);
+      gluSphere(joints,0.2, 16, 16);
+      free(joints);
+#endif
+      if (leg)
+        glRotatef((GLfloat) heel1, 1.0, 0.0, 0.0);
+      else
+        glRotatef((GLfloat) heel2, 1.0, 0.0, 0.0);
+      /* glTranslatef(0.0, -0.2, 0.0); */
+      glTranslatef(0.0, -1.7, 0.0);
+#ifdef LIGHT
+      SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+      glColor3f(1.0, 1.0, 0.0);
+      Box(0.25, 3.0, 0.25, solid);
+      glTranslatef(0.0, -1.7, 0.0);
+#ifdef LIGHT
+      SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+      glColor3f(0.5, 0.5, 0.5);
+#ifdef SPHERE
+      joints = gluNewQuadric();
+      if(!solid)gluQuadricDrawStyle(joints, GLU_LINE);
+      gluSphere(joints, 0.2, 16, 16);
+#endif
+      if (leg)
+        glRotatef((GLfloat) - heel1, 1.0, 0.0, 0.0);
+      else
+        glRotatef((GLfloat) - heel2, 1.0, 0.0, 0.0);
+      glTranslatef(0.0, -0.45, 0.0);
+#ifdef LIGHT
+      SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+      glColor3f(1.0, 1.0, 0.0);
+      Box(1.0, 0.5, 1.0, solid);
+      if (!k && !l) {
+        int j;
+        glTranslatef(-0.4, -0.8, 0.5);
+        if (leg)
+          glRotatef((GLfloat) ankle1, 1.0, 0.0, 0.0);
+        else
+          glRotatef((GLfloat) ankle2, 1.0, 0.0, 0.0);
+        glRotatef(90.0, 0.0, 1.0, 0.0);
+        if (!solid)
+          gluQuadricDrawStyle(ankle, GLU_LINE);
+        gluCylinder(ankle, 0.8, 0.8, 1.8, 16, 10);
+        for (j = 0; j < 2; j++) {
+          ankle_face[j] = gluNewQuadric();
+          if (!solid)
+            gluQuadricDrawStyle(ankle_face[j], GLU_LINE);
+          if (j) {
+            glScalef(-1.0, 1.0, 1.0);
+            glTranslatef(0.0, 0.0, 1.8);
+          }
+          gluDisk(ankle_face[j], 0.0, 0.8, 16, 10);
+          if (j)
+            glTranslatef(0.0, 0.0, -1.8);
+        }
+        glScalef(-1.0, 1.0, 1.0);
+        glRotatef(-90.0, 0.0, 1.0, 0.0);
+        glTranslatef(0.95, -0.8, 0.0);
+        glCallList(SOLID_MECH_FOOT);
+      }
+      glPopMatrix();
+    }
+  }
+}
+void
+RocketPod(char solid)
+{
+  int i, j, k = 0;
+  GLUquadricObj *rocket[6];
+  GLUquadricObj *rocket1[6];
+  glNewList(SOLID_MECH_ROCKET, GL_COMPILE);
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glColor3f(0.5, 0.5, 0.5);
+  glScalef(0.4, 0.4, 0.4);
+  glRotatef(45.0, 0.0, 0.0, 1.0);
+  glTranslatef(1.0, 0.0, 0.0);
+  Box(2.0, 0.5, 3.0, solid);
+  glTranslatef(1.0, 0.0, 0.0);
+  glRotatef(45.0, 0.0, 0.0, 1.0);
+  glTranslatef(0.5, 0.0, 0.0);
+  Box(1.2, 0.5, 3.0, solid);
+  glTranslatef(2.1, 0.0, 0.0);
+  glRotatef(-90.0, 0.0, 0.0, 1.0);
+#ifdef LIGHT
+  SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess);
+#endif
+  glColor3f(1.0, 1.0, 0.0);
+  Box(2.0, 3.0, 4.0, solid);
+  glTranslatef(-0.5, -1.0, 1.3);
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 3; j++) {
+      rocket[k] = gluNewQuadric();
+      rocket1[k] = gluNewQuadric();
+      if (!solid) {
+        gluQuadricDrawStyle(rocket[k], GLU_LINE);
+        gluQuadricDrawStyle(rocket1[k], GLU_LINE);
+      }
+      glTranslatef(i, j, 0.6);
+#ifdef LIGHT
+      SetMaterial(mat_specular3, mat_ambient3, mat_diffuse3, mat_shininess3);
+#endif
+      glColor3f(1.0, 1.0, 1.0);
+      gluCylinder(rocket[k], 0.4, 0.4, 0.3, 16, 10);
+      glTranslatef(0.0, 0.0, 0.3);
+#ifdef LIGHT
+      SetMaterial(mat_specular4, mat_ambient4, mat_diffuse4, mat_shininess4);
+#endif
+      glColor3f(0.0, 1.0, 0.0);
+      gluCylinder(rocket1[k], 0.4, 0.0, 0.5, 16, 10);
+      k++;
+      glTranslatef(-i, -j, -0.9);
+    }
+  }
+  glEndList();
+}
+void
+Enviro(char solid)
+{
+  int i, j;
+  glNewList(SOLID_ENVIRO, GL_COMPILE);
+  SetMaterial(mat_specular4, mat_ambient4, mat_diffuse4, mat_shininess4);
+  glColor3f(0.0, 1.0, 0.0);
+  Box(20.0, 0.5, 30.0, solid);
+  SetMaterial(mat_specular4, mat_ambient3, mat_diffuse2, mat_shininess);
+  glColor3f(0.6, 0.6, 0.6);
+  glTranslatef(0.0, 0.0, -10.0);
+  for (j = 0; j < 6; j++) {
+    for (i = 0; i < 2; i++) {
+      if (i)
+        glScalef(-1.0, 1.0, 1.0);
+      glTranslatef(10.0, 4.0, 0.0);
+      Box(4.0, 8.0, 2.0, solid);
+      glTranslatef(0.0, -1.0, -3.0);
+      Box(4.0, 6.0, 2.0, solid);
+      glTranslatef(-10.0, -3.0, 3.0);
+    }
+    glScalef(-1.0, 1.0, 1.0);
+    glTranslatef(0.0, 0.0, 5.0);
+  }
+  glEndList();
+}
+void
+Toggle(void)
+{
+  if (solid_part)
+    solid_part = 0;
+  else
+    solid_part = 1;
+}
+void
+disable(void)
+{
+  glDisable(GL_LIGHTING);
+  glDisable(GL_DEPTH_TEST);
+  glDisable(GL_NORMALIZE);
+  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+}
+void
+lighting(void)
+{
+  GLfloat position[] =
+  {0.0, 0.0, 2.0, 1.0};
+#ifdef MOVE_LIGHT
+  glRotatef((GLfloat) lightturn1, 1.0, 0.0, 0.0);
+  glRotatef((GLfloat) lightturn, 0.0, 1.0, 0.0);
+  glRotatef(0.0, 1.0, 0.0, 0.0);
+#endif
+  glEnable(GL_LIGHTING);
+  glEnable(GL_LIGHT0);
+  glEnable(GL_NORMALIZE);
+  /* glEnable(GL_FLAT); */
+  /*  glDepthFunc(GL_LESS); */
+  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+  glLightfv(GL_LIGHT0, GL_POSITION, position);
+  glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 80.0);
+  glTranslatef(0.0, 0.0, 2.0);
+  glDisable(GL_LIGHTING);
+  Box(0.1, 0.1, 0.1, 0);
+  glEnable(GL_LIGHTING);
+  /* glEnable(GL_CULL_FACE); */
+}
+void
+DrawMech(void)
+{
+  int i, j;
+  glScalef(0.5, 0.5, 0.5);
+  glPushMatrix();
+  glTranslatef(0.0, -0.75, 0.0);
+  glRotatef((GLfloat) tilt, 1.0, 0.0, 0.0);
+  glRotatef(90.0, 1.0, 0.0, 0.0);
+#ifdef HIP
+  glCallList(SOLID_MECH_HIP);
+#endif
+  glRotatef(-90.0, 1.0, 0.0, 0.0);
+  glTranslatef(0.0, 0.75, 0.0);
+  glPushMatrix();
+  glRotatef((GLfloat) pivot, 0.0, 1.0, 0.0);
+  glPushMatrix();
+#ifdef TORSO
+  glCallList(SOLID_MECH_TORSO);
+#endif
+  glPopMatrix();
+  glPushMatrix();
+  glTranslatef(0.5, 0.5, 0.0);
+#ifdef ROCKET_POD
+  glCallList(SOLID_MECH_ROCKET);
+#endif
+  glPopMatrix();
+  for (i = 0; i < 2; i++) {
+    glPushMatrix();
+    if (i)
+      glScalef(-1.0, 1.0, 1.0);
+    glTranslatef(1.5, 0.0, 0.0);
+#ifdef SHOULDER
+    glCallList(SOLID_MECH_SHOULDER);
+#endif
+    glTranslatef(0.9, 0.0, 0.0);
+    if (i) {
+      glRotatef((GLfloat) lat1, 0.0, 0.0, 1.0);
+      glRotatef((GLfloat) shoulder1, 1.0, 0.0, 0.0);
+      glRotatef((GLfloat) shoulder3, 0.0, 1.0, 0.0);
+    } else {
+      glRotatef((GLfloat) lat2, 0.0, 0.0, 1.0);
+      glRotatef((GLfloat) shoulder2, 1.0, 0.0, 0.0);
+      glRotatef((GLfloat) shoulder4, 0.0, 1.0, 0.0);
+    }
+    glTranslatef(0.0, -1.4, 0.0);
+#ifdef UPPER_ARM
+    glCallList(SOLID_MECH_UPPER_ARM);
+#endif
+    glTranslatef(0.0, -2.9, 0.0);
+    if (i)
+      glRotatef((GLfloat) elbow1, 1.0, 0.0, 0.0);
+    else
+      glRotatef((GLfloat) elbow2, 1.0, 0.0, 0.0);
+    glTranslatef(0.0, -0.9, -0.2);
+#ifdef LOWER_ARM
+    glCallList(SOLID_MECH_FOREARM);
+    glPushMatrix();
+    glTranslatef(0.0, 0.0, 2.0);
+    glRotatef((GLfloat) fire, 0.0, 0.0, 1.0);
+    glCallList(SOLID_MECH_VULCAN);
+    glPopMatrix();
+#endif
+    glPopMatrix();
+  }
+  glPopMatrix();
+  glPopMatrix();
+  for (j = 0; j < 2; j++) {
+    glPushMatrix();
+    if (j) {
+      glScalef(-0.5, 0.5, 0.5);
+      leg = 1;
+    } else {
+      glScalef(0.5, 0.5, 0.5);
+      leg = 0;
+    }
+    glTranslatef(2.0, -1.5, 0.0);
+    if (j) {
+      glRotatef((GLfloat) hip11, 1.0, 0.0, 0.0);
+      glRotatef((GLfloat) hip12, 0.0, 0.0, 1.0);
+    } else {
+      glRotatef((GLfloat) hip21, 1.0, 0.0, 0.0);
+      glRotatef((GLfloat) hip22, 0.0, 0.0, 1.0);
+    }
+    glTranslatef(0.0, 0.3, 0.0);
+#ifdef UPPER_LEG
+    glPushMatrix();
+    glCallList(SOLID_MECH_UPPER_LEG);
+    glPopMatrix();
+#endif
+    glTranslatef(0.0, -8.3, -0.4);
+    if (j)
+      glRotatef((GLfloat) - hip12, 0.0, 0.0, 1.0);
+    else
+      glRotatef((GLfloat) - hip22, 0.0, 0.0, 1.0);
+    glTranslatef(-0.5, -0.85, -0.5);
+#ifdef LOWER_LEG
+    LowerLeg(1);
+#endif
+    glPopMatrix();
+  }
+}
+void
+display(void)
+{
+  glClearColor(0.0, 0.0, 0.0, 0.0);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glEnable(GL_DEPTH_TEST);
+  glPushMatrix();
+  glRotatef((GLfloat) turn, 0.0, 1.0, 0.0);
+  glRotatef((GLfloat) turn1, 1.0, 0.0, 0.0);
+#ifdef LIGHT
+  if (solid_part) {
+    glPushMatrix();
+    lighting();
+    glPopMatrix();
+  } else
+    disable();
+#endif
+#ifdef DRAW_MECH
+  glPushMatrix();
+  glTranslatef(0.0, elevation, 0.0);
+  DrawMech();
+  glPopMatrix();
+#endif
+#ifdef DRAW_ENVIRO
+  glPushMatrix();
+  if (distance >= 20.136)
+    distance = 0.0;
+  glTranslatef(0.0, -5.0, -distance);
+  glCallList(SOLID_ENVIRO);
+  glTranslatef(0.0, 0.0, 10.0);
+  glCallList(SOLID_ENVIRO);
+  glPopMatrix();
+#endif
+  glPopMatrix();
+  glFlush();
+  tkSwapBuffers();
+}
+void
+init(void)
+{
+  char i = 1;
+#ifdef LIGHT
+  SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2);
+#endif
+  glEnable(GL_DEPTH_TEST);
+  MechTorso(i);
+  MechHip(i);
+  Shoulder(i);
+  RocketPod(i);
+  UpperArm(i);
+  ForeArm(i);
+  UpperLeg(i);
+  Foot(i);
+  VulcanGun(i);
+  Enviro(i);
+}
+void
+reshape(int w, int h)
+{
+  glViewport(0, 0, w, h);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  gluPerspective(65.0, (GLfloat) w / (GLfloat) h, 1.0, 20.0);
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+  glTranslatef(0.0, 1.2, -5.5);  /* viewing transform  */
+}
+#ifdef ANIMATION
+void
+animation_walk(void)
+{
+  float angle;
+  static int step;
+  if (step == 0 || step == 2) {
+    /* for(frame=3.0; frame<=21.0; frame=frame+3.0){ */
+    if (frame >= 0.0 && frame <= 21.0) {
+      if (frame == 0.0)
+        frame = 3.0;
+      angle = (180 / PI) * (acos(((cos((PI / 180) * frame) * 2.043) + 1.1625) / 3.2059));
+      if (frame > 0) {
+        elevation = -(3.2055 - (cos((PI / 180) * angle) * 3.2055));
+      } else
+        elevation = 0.0;
+      if (step == 0) {
+        hip11 = -(frame * 1.7);
+        if (1.7 * frame > 15)
+          heel1 = frame * 1.7;
+        heel2 = 0;
+        ankle1 = frame * 1.7;
+        if (frame > 0)
+          hip21 = angle;
+        else
+          hip21 = 0;
+        ankle2 = -hip21;
+        shoulder1 = frame * 1.5;
+        shoulder2 = -frame * 1.5;
+        elbow1 = frame;
+        elbow2 = -frame;
+      } else {
+        hip21 = -(frame * 1.7);
+        if (1.7 * frame > 15)
+          heel2 = frame * 1.7;
+        heel1 = 0;
+        ankle2 = frame * 1.7;
+        if (frame > 0)
+          hip11 = angle;
+        else
+          hip11 = 0;
+        ankle1 = -hip11;
+        shoulder1 = -frame * 1.5;
+        shoulder2 = frame * 1.5;
+        elbow1 = -frame;
+        elbow2 = frame;
+      }
+      if (frame == 21)
+        step++;
+      if (frame < 21)
+        frame = frame + 3.0;
+    }
+  }
+  if (step == 1 || step == 3) {
+    /* for(x=21.0; x>=0.0; x=x-3.0){ */
+    if (frame <= 21.0 && frame >= 0.0) {
+      angle = (180 / PI) * (acos(((cos((PI / 180) * frame) * 2.043) + 1.1625) / 3.2029));
+      if (frame > 0)
+        elevation = -(3.2055 - (cos((PI / 180) * angle) * 3.2055));
+      else
+        elevation = 0.0;
+      if (step == 1) {
+        elbow2 = hip11 = -frame;
+        elbow1 = heel1 = frame;
+        heel2 = 15;
+        ankle1 = frame;
+        if (frame > 0)
+          hip21 = angle;
+        else
+          hip21 = 0;
+        ankle2 = -hip21;
+        shoulder1 = 1.5 * frame;
+        shoulder2 = -frame * 1.5;
+      } else {
+        elbow1 = hip21 = -frame;
+        elbow2 = heel2 = frame;
+        heel1 = 15;
+        ankle2 = frame;
+        if (frame > 0)
+          hip11 = angle;
+        else
+          hip11 = 0;
+        ankle1 = -hip11;
+        shoulder1 = -frame * 1.5;
+        shoulder2 = frame * 1.5;
+      }
+      if (frame == 0.0)
+        step++;
+      if (frame > 0)
+        frame = frame - 3.0;
+    }
+  }
+  if (step == 4)
+    step = 0;
+  distance += 0.1678;
+}
+void
+animation(void)
+{
+  animation_walk();
+}
+#endif
+GLenum key(int key, GLenum mask)
+{
+  int i = 0;
+  switch (key) {
+    /* start arm control functions */
+  case 'q':{
+      shoulder2Subtract();
+      i++;
+    }
+    break;
+  case 'a':{
+      shoulder2Add();
+      i++;
+    }
+    break;
+  case 'w':{
+      shoulder1Subtract();
+      i++;
+    }
+    break;
+  case 's':{
+      shoulder1Add();
+      i++;
+    }
+    break;
+  case '2':{
+      shoulder3Add();
+      i++;
+    }
+    break;
+  case '1':{
+      shoulder4Add();
+      i++;
+    }
+    break;
+  case '4':{
+      shoulder3Subtract();
+      i++;
+    }
+    break;
+  case '3':{
+      shoulder4Subtract();
+      i++;
+    }
+    break;
+  case 'z':{
+      lat2Raise();
+      i++;
+    }
+    break;
+  case 'Z':{
+      lat2Lower();
+      i++;
+    }
+    break;
+  case 'x':{
+      lat1Raise();
+      i++;
+    }
+    break;
+  case 'X':{
+      lat1Lower();
+      i++;
+    }
+    break;
+  case 'A':{
+      elbow2Add();
+      i++;
+    }
+    break;
+  case 'Q':{
+      elbow2Subtract();
+      i++;
+    }
+    break;
+  case 'S':{
+      elbow1Add();
+      i++;
+    }
+    break;
+  case 'W':{
+      elbow1Subtract();
+      i++;
+    }
+    break;
+    /* end of arm control functions */
+    /* start of torso control functions */
+  case 'd':{
+      RotateAdd();
+      i++;
+    }
+    break;
+  case 'g':{
+      RotateSubtract();
+      i++;
+    }
+    break;
+  case 'r':{
+      MechTiltAdd();
+      i++;
+    }
+    break;
+  case 'f':{
+      MechTiltSubtract();
+      i++;
+    }
+    break;
+    /* end of torso control functions */
+    /* start of leg control functions */
+  case 'h':{
+      RaiseLeg2Forward();
+      i++;
+    }
+    break;
+  case 'y':{
+      LowerLeg2Backwards();
+      i++;
+    }
+    break;
+  case 'Y':{
+      RaiseLeg2Outwards();
+      i++;
+    }
+    break;
+  case 'H':{
+      LowerLeg2Inwards();
+      i++;
+    }
+    break;
+  case 'j':{
+      RaiseLeg1Forward();
+      i++;
+    }
+    break;
+  case 'u':{
+      LowerLeg1Backwards();
+      i++;
+    }
+    break;
+  case 'U':{
+      RaiseLeg1Outwards();
+      i++;
+    }
+    break;
+  case 'J':{
+      LowerLeg1Inwards();
+      i++;
+    }
+    break;
+  case 'N':{
+      Heel2Add();
+      i++;
+    }
+    break;
+  case 'n':{
+      Heel2Subtract();
+      i++;
+    }
+    break;
+  case 'M':{
+      Heel1Add();
+      i++;
+    }
+    break;
+  case 'm':{
+      Heel1Subtract();
+      i++;
+    }
+    break;
+  case 'k':{
+      Ankle2Add();
+      i++;
+    }
+    break;
+  case 'K':{
+      Ankle2Subtract();
+      i++;
+    }
+    break;
+  case 'l':{
+      Ankle1Add();
+      i++;
+    }
+    break;
+  case 'L':{
+      Ankle1Subtract();
+      i++;
+    }
+    break;
+    /* end of leg control functions */
+    /* start of light source position functions */
+  case 'p':{
+      LightTurnRight();
+      i++;
+    }
+    break;
+  case 'i':{
+      LightTurnLeft();
+      i++;
+    }
+    break;
+  case 'o':{
+      LightForwards();
+      i++;
+    }
+    break;
+  case '9':{
+      LightBackwards();
+      i++;
+    }
+    break;
+    /* end of light source position functions */
+    /* start of misc functions */
+  case 't':
+    Toggle();
+    break;
+  case KEY_LEFT:
+      TurnLeft();
+      break;
+  case KEY_RIGHT:
+      TurnRight();
+      break;
+  case KEY_UP:
+      TurnBackwards();
+      break;
+  case KEY_DOWN:
+      TurnForwards();
+      break;
+  case ' ':
+      FireCannon();
+  }
+  return 0;
+}
+void printHelp(void)
+{
+  printf("at the shoulders:");
+  printf("forward       : q,w");
+  printf("backwards     : a,s");
+  printf("outwards      : z,x");
+  printf("inwards       : Z,X");
+#if 0
+  glut_menu[6] = glutCreateMenu(null_select);
+  printf("upwards       : Q,W\n");
+  printf("downwards     : A,S\n");
+  printf("outwards      : 1,2\n");
+  printf("inwards       : 3,4\n");
+  glut_menu[1] = glutCreateMenu(null_select);
+  printf(" : Page_up\n");
+  glut_menu[8] = glutCreateMenu(null_select);
+  printf("forward       : y,u\n");
+  printf("backwards     : h.j\n");
+  printf("outwards      : Y,U\n");
+  printf("inwards       : H,J\n");
+  glut_menu[9] = glutCreateMenu(null_select);
+  printf("forward       : n,m\n");
+  printf("backwards     : N,M\n");
+  glut_menu[9] = glutCreateMenu(null_select);
+  printf("forward       : n,m\n");
+  printf("backwards     : N,M\n");
+  glut_menu[10] = glutCreateMenu(null_select);
+  printf("toes up       : K,L\n");
+  printf("toes down     : k,l\n");
+  glut_menu[11] = glutCreateMenu(null_select);
+  printf("right         : right arrow\n");
+  printf("left          : left arrow\n");
+  printf("down          : up arrow\n");
+  printf("up            : down arrow\n");
+  glut_menu[12] = glutCreateMenu(null_select);
+  printf("right         : p\n");
+  printf("left          : i\n");
+  printf("up            : 9\n");
+  printf("down          : o\n");
+  glut_menu[4] = glutCreateMenu(NULL);
+  glutAddSubMenu("at the elbows?", glut_menu[6]);
+  glut_menu[7] = glutCreateMenu(NULL);
+  glutAddSubMenu("at the hip? ", glut_menu[8]);
+  glutAddSubMenu("at the knees?", glut_menu[9]);
+  glutAddSubMenu("at the ankles? ", glut_menu[10]);
+  printf("turn left    : d\n");
+  printf("turn right    : g\n");
+  glut_menu[3] = glutCreateMenu(null_select);
+  printf("tilt backwards : f\n");
+  printf("tilt forwards  : r\n");
+  glut_menu[0] = glutCreateMenu(NULL);
+  glutAddSubMenu("move the arms.. ", glut_menu[4]);
+  glutAddSubMenu("fire the vulcan guns?", glut_menu[1]);
+  glutAddSubMenu("move the legs.. ", glut_menu[7]);
+  glutAddSubMenu("move the torso?", glut_menu[2]);
+  glutAddSubMenu("move the hip?", glut_menu[3]);
+  glutAddSubMenu("rotate the scene..", glut_menu[11]);
+#ifdef MOVE_LIGHT
+  glutAddSubMenu("rotate the light source..", glut_menu[12]);
+#endif
+  glutCreateMenu(menu_select);
+#ifdef ANIMATION
+  printf("Start Walk", 1);
+  printf("Stop Walk", 2);
+#endif
+  printf("Toggle Wireframe", 3);
+  glutAddSubMenu("How do I ..", glut_menu[0]);
+  printfy("Quit", 4);
+  glutAttachMenu(GLUT_LEFT_BUTTON);
+  glutAttachMenu(GLUT_RIGHT_BUTTON);
+#endif
+}
+void idle( void )
+{
+    /* animate the mech */
+    animation();
+    /* draw the Mech */
+    display();
+}
+/* #define PROFILE */
+#ifdef PROFILE
+extern int count_triangles;
+#endif
+// #define LINUX_TEST_FLOAT
+#ifdef LINUX_TEST_FLOAT
+#include <fpu_control.h>
+#endif
+int
+main(int argc, char **argv)
+{
+#ifdef LINUX_TEST_FLOAT
+  /* for debuging floating point errors under Linux */
+  __setfpucw ( 0x1372 );
+#endif
+  Toggle();
+  return ui_loop(argc, argv, "mech");
+}

 /programs/develop/libraries/TinyGL/examples/nanox.c
 ,0 → 1,113
+/*
+ * Demonstration program for Nano-X graphics.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define MWINCLUDECOLORS
+#include <microwin/nano-X.h>
+#include <GL/gl.h>
+#include <GL/nglx.h>
+#include "ui.h"
+static  GR_WINDOW_ID    w1;             /* id for large window */
+static  GR_GC_ID        gc1;            /* graphics context for text */
+void errorcatcher();                    /* routine to handle errors */
+void tkSwapBuffers(void)
+{
+    nglXSwapBuffers(w1);
+}
+int
+ui_loop(int argc,char **argv, const char *name)
+{
+        GR_EVENT        event;          /* current event */
+        GR_IMAGE_ID     id = 0;
+        NGLXContext cx;
+        int width, height, k;
+        if (GrOpen() < 0) {
+                fprintf(stderr, "cannot open graphics\n");
+                exit(1);
+        }
+        width = 400;
+        height = 300;
+        GrSetErrorHandler(errorcatcher);
+        w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10, 10, width, height, 4, BLACK, WHITE);
+        GrSelectEvents(w1, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN);
+        GrMapWindow(w1);
+        gc1 = GrNewGC();
+        GrSetGCForeground(gc1, WHITE);
+        cx = nglXCreateContext(NULL, 0);
+        nglXMakeCurrent(w1, cx);
+        init();
+        reshape(width, height);
+        while (1) {
+            GrCheckNextEvent(&event);
+            switch(event.type) {
+            case GR_EVENT_TYPE_CLOSE_REQ:
+                GrFreeImage(id);
+                GrClose();
+                exit(0);
+            case GR_EVENT_TYPE_EXPOSURE:
+                break;
+            case GR_EVENT_TYPE_KEY_DOWN:
+                {
+                    GR_EVENT_KEYSTROKE *kp = &event.keystroke;
+                    /* XXX: nanoX special keys are totally bugged ! */
+                    switch(kp->ch) {
+                    case 81:
+                        k = KEY_LEFT;
+                        break;
+                    case 83:
+                        k = KEY_RIGHT;
+                        break;
+                    case 82:
+                        k = KEY_UP;
+                        break;
+                    case 84:
+                        k = KEY_DOWN;
+                        break;
+                    default:
+                        k = kp->ch;
+                        break;
+                    }
+                    key(k, 0);
+                }
+                break;
+            default:
+                idle();
+                break;
+            }
+        }
+        return 0;
+}
+/*
+ * Here on an unrecoverable error.
+ */
+void
+errorcatcher(code, name, id)
+        GR_ERROR        code;           /* error code */
+        GR_FUNC_NAME    name;           /* function name which failed */
+        GR_ID           id;             /* resource id */
+{
+        GrClose();
+        fprintf(stderr, "DEMO ERROR: code %d, function %s, resource id %d\n",
+                code, name, id);
+        exit(1);
+}

 /programs/develop/libraries/TinyGL/examples/spin.c
 ,0 → 1,160
+/* spin.c */
+/*
+ * Spinning box.  This program is in the public domain.
+ *
+ * Brian Paul
+ */
+#include <math.h>
+#include <stdio.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include "ui.h"
+static GLfloat Xrot, Xstep;
+static GLfloat Yrot, Ystep;
+static GLfloat Zrot, Zstep;
+static GLfloat Step = 5.0;
+static GLfloat Scale = 1.0;
+static GLuint Object;
+static GLuint make_object( void )
+{
+   GLuint list;
+   list = glGenLists( 1 );
+   glNewList( list, GL_COMPILE );
+   glBegin( GL_LINE_LOOP );
+   glColor3f( 1.0, 1.0, 1.0 );
+   glVertex3f(  1.0,  0.5, -0.4 );
+   glColor3f( 1.0, 0.0, 0.0 );
+   glVertex3f(  1.0, -0.5, -0.4 );
+   glColor3f( 0.0, 1.0, 0.0 );
+   glVertex3f( -1.0, -0.5, -0.4 );
+   glColor3f( 0.0, 0.0, 1.0 );
+   glVertex3f( -1.0,  0.5, -0.4 );
+   glEnd();
+   glColor3f( 1.0, 1.0, 1.0 );
+   glBegin( GL_LINE_LOOP );
+   glVertex3f(  1.0,  0.5, 0.4 );
+   glVertex3f(  1.0, -0.5, 0.4 );
+   glVertex3f( -1.0, -0.5, 0.4 );
+   glVertex3f( -1.0,  0.5, 0.4 );
+   glEnd();
+   glBegin( GL_LINES );
+   glVertex3f(  1.0,  0.5, -0.4 );   glVertex3f(  1.0,  0.5, 0.4 );
+   glVertex3f(  1.0, -0.5, -0.4 );   glVertex3f(  1.0, -0.5, 0.4 );
+   glVertex3f( -1.0, -0.5, -0.4 );   glVertex3f( -1.0, -0.5, 0.4 );
+   glVertex3f( -1.0,  0.5, -0.4 );   glVertex3f( -1.0,  0.5, 0.4 );
+   glEnd();
+   glEndList();
+   return list;
+}
+void reshape( int width, int height )
+{
+   glViewport(0, 0, (GLint)width, (GLint)height);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
+   glMatrixMode(GL_MODELVIEW);
+}
+GLenum key(int k, GLenum mask)
+{
+   switch (k) {
+   case KEY_ESCAPE:
+       exit(0);
+   }
+   return GL_FALSE;
+}
+void draw( void )
+{
+   glClear( GL_COLOR_BUFFER_BIT );
+   glPushMatrix();
+   glTranslatef( 0.0, 0.0, -10.0 );
+   glScalef( Scale, Scale, Scale );
+   if (Xstep) {
+      glRotatef( Xrot, 1.0, 0.0, 0.0 );
+   }
+   else if (Ystep) {
+      glRotatef( Yrot, 0.0, 1.0, 0.0 );
+   }
+   else {
+      glRotatef( Zrot, 0.0, 0.0, 1.0 );
+   }
+   glCallList( Object );
+   glPopMatrix();
+   glFlush();
+   tkSwapBuffers();
+}
+void idle( void )
+{
+   Xrot += Xstep;
+   Yrot += Ystep;
+   Zrot += Zstep;
+   if (Xrot>=360.0) {
+      Xrot = Xstep = 0.0;
+      Ystep = Step;
+   }
+   else if (Yrot>=360.0) {
+      Yrot = Ystep = 0.0;
+      Zstep = Step;
+   }
+   else if (Zrot>=360.0) {
+      Zrot = Zstep = 0.0;
+      Xstep = Step;
+   }
+   draw();
+}
+void init(void)
+{
+   Object = make_object();
+   glCullFace( GL_BACK );
+/*   glEnable( GL_CULL_FACE );*/
+   glDisable( GL_DITHER );
+   glShadeModel( GL_FLAT );
+/*   glEnable( GL_DEPTH_TEST ); */
+   Xrot = Yrot = Zrot = 0.0;
+   Xstep = Step;
+   Ystep = Zstep = 0.0;
+}
+int main( int argc, char *argv[] )
+{
+    return ui_loop(argc, argv, "spin");
+}

 /programs/develop/libraries/TinyGL/examples/texobj.c
 ,0 → 1,193
+/*
+ * Example of using the 1.1 texture object functions.
+ * Also, this demo utilizes Mesa's fast texture map path.
+ *
+ * Brian Paul   June 1996
+ */
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include "ui.h"
+static GLuint TexObj[2];
+static GLfloat Angle = 0.0f;
+static int cnt=0,v=0;
+void
+draw(void)
+{
+  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+  glColor3f(1.0, 1.0, 1.0);
+  /* draw first polygon */
+  glPushMatrix();
+  glTranslatef(-1.0, 0.0, 0.0);
+  glRotatef(Angle, 0.0, 0.0, 1.0);
+  glBindTexture(GL_TEXTURE_2D, TexObj[v]);
+  glEnable(GL_TEXTURE_2D);
+  glBegin(GL_QUADS);
+  glTexCoord2f(0.0, 0.0);
+  glVertex2f(-1.0, -1.0);
+  glTexCoord2f(1.0, 0.0);
+  glVertex2f(1.0, -1.0);
+  glTexCoord2f(1.0, 1.0);
+  glVertex2f(1.0, 1.0);
+  glTexCoord2f(0.0, 1.0);
+  glVertex2f(-1.0, 1.0);
+  glEnd();
+  glDisable(GL_TEXTURE_2D);
+  glPopMatrix();
+  /* draw second polygon */
+  glPushMatrix();
+  glTranslatef(1.0, 0.0, 0.0);
+  glRotatef(Angle - 90.0, 0.0, 1.0, 0.0);
+  glBindTexture(GL_TEXTURE_2D, TexObj[1-v]);
+  glEnable(GL_TEXTURE_2D);
+  glBegin(GL_QUADS);
+  glTexCoord2f(0.0, 0.0);
+  glVertex2f(-1.0, -1.0);
+  glTexCoord2f(1.0, 0.0);
+  glVertex2f(1.0, -1.0);
+  glTexCoord2f(1.0, 1.0);
+  glVertex2f(1.0, 1.0);
+  glTexCoord2f(0.0, 1.0);
+  glVertex2f(-1.0, 1.0);
+  glEnd();
+  glDisable(GL_TEXTURE_2D);
+  glPopMatrix();
+  tkSwapBuffers();
+}
+/* new window size or exposure */
+void
+reshape(int width, int height)
+{
+  glViewport(0, 0, (GLint) width, (GLint) height);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  /* glOrtho( -3.0, 3.0, -3.0, 3.0, -10.0, 10.0 ); */
+  glFrustum(-2.0, 2.0, -2.0, 2.0, 6.0, 20.0);
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+  glTranslatef(0.0, 0.0, -8.0);
+}
+void bind_texture(int texobj,int image)
+{
+  static int width = 8, height = 8;
+  static int color[2][3]={
+    {255,0,0},
+    {0,255,0},
+  };
+  GLubyte tex[64][3];
+  static GLubyte texchar[2][8*8] = {
+  {
+, 0, 0, 0, 0, 0, 0, 0,
+, 0, 0, 0, 1, 0, 0, 0,
+, 0, 0, 1, 1, 0, 0, 0,
+, 0, 0, 0, 1, 0, 0, 0,
+, 0, 0, 0, 1, 0, 0, 0,
+, 0, 0, 0, 1, 0, 0, 0,
+, 0, 0, 1, 1, 1, 0, 0,
+, 0, 0, 0, 0, 0, 0, 0},
+  {
+, 0, 0, 0, 0, 0, 0, 0,
+, 0, 0, 2, 2, 0, 0, 0,
+, 0, 2, 0, 0, 2, 0, 0,
+, 0, 0, 0, 0, 2, 0, 0,
+, 0, 0, 0, 2, 0, 0, 0,
+, 0, 0, 2, 0, 0, 0, 0,
+, 0, 2, 2, 2, 2, 0, 0,
+, 0, 0, 0, 0, 0, 0, 0}};
+  int i,j;
+  glBindTexture(GL_TEXTURE_2D, texobj);
+  /* red on white */
+  for (i = 0; i < height; i++) {
+    for (j = 0; j < width; j++) {
+      int p = i * width + j;
+      if (texchar[image][(height - i - 1) * width + j]) {
+        tex[p][0] = color[image][0];
+        tex[p][1] = color[image][1];
+        tex[p][2] = color[image][2];
+      } else {
+        tex[p][0] = 255;
+        tex[p][1] = 255;
+        tex[p][2] = 255;
+      }
+    }
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0,
+    GL_RGB, GL_UNSIGNED_BYTE, tex);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  /* end of texture object */
+}
+void
+init(void)
+{
+  glEnable(GL_DEPTH_TEST);
+  /* Setup texturing */
+  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
+  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+  /* generate texture object IDs */
+  glGenTextures(2, TexObj);
+  bind_texture(TexObj[0],0);
+  bind_texture(TexObj[1],1);
+}
+void
+idle(void)
+{
+  Angle += 2.0;
+  if (++cnt==5) {
+    cnt=0;
+    v=!v;
+  }
+  draw();
+}
+/* change view angle, exit upon ESC */
+GLenum key(int k, GLenum mask)
+{
+   switch (k) {
+      case 'q':
+      case KEY_ESCAPE:
+          exit(0);
+   }
+   return GL_FALSE;
+}
+int main(int argc, char **argv)
+{
+    return ui_loop(argc, argv, "texobj");
+}

 /programs/develop/libraries/TinyGL/examples/ui.h
 ,0 → 1,17
+/*
+ * tk like ui
+ */
+void draw( void );
+void idle( void );
+GLenum key(int k, GLenum mask);
+void reshape( int width, int height );
+void init( void );
+int ui_loop(int argc, char **argv, const char *name);
+void tkSwapBuffers(void);
+#define KEY_UP     0xe000
+#define KEY_DOWN   0xe001
+#define KEY_LEFT   0xe002
+#define KEY_RIGHT  0xe003
+#define KEY_ESCAPE 0xe004

 /programs/develop/libraries/TinyGL/include/GL/gl.h
 ,0 → 1,838
+/*
+ * The following constants come from Mesa
+ */
+#ifndef GL_H
+#define GL_H
+#define GL_VERSION_1_1 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+enum {
+        /* Boolean values */
+        GL_FALSE                        = 0,
+        GL_TRUE                         = 1,
+        /* Data types */
+        GL_BYTE                         = 0x1400,
+        GL_UNSIGNED_BYTE                = 0x1401,
+        GL_SHORT                        = 0x1402,
+        GL_UNSIGNED_SHORT               = 0x1403,
+        GL_INT                          = 0x1404,
+        GL_UNSIGNED_INT                 = 0x1405,
+        GL_FLOAT                        = 0x1406,
+        GL_DOUBLE                       = 0x140A,
+        GL_2_BYTES                      = 0x1407,
+        GL_3_BYTES                      = 0x1408,
+        GL_4_BYTES                      = 0x1409,
+        /* Primitives */
+        GL_LINES                        = 0x0001,
+        GL_POINTS                       = 0x0000,
+        GL_LINE_STRIP                   = 0x0003,
+        GL_LINE_LOOP                    = 0x0002,
+        GL_TRIANGLES                    = 0x0004,
+        GL_TRIANGLE_STRIP               = 0x0005,
+        GL_TRIANGLE_FAN                 = 0x0006,
+        GL_QUADS                        = 0x0007,
+        GL_QUAD_STRIP                   = 0x0008,
+        GL_POLYGON                      = 0x0009,
+        GL_EDGE_FLAG                    = 0x0B43,
+        /* Vertex Arrays */
+        GL_VERTEX_ARRAY                 = 0x8074,
+        GL_NORMAL_ARRAY                 = 0x8075,
+        GL_COLOR_ARRAY                  = 0x8076,
+        GL_INDEX_ARRAY                  = 0x8077,
+        GL_TEXTURE_COORD_ARRAY          = 0x8078,
+        GL_EDGE_FLAG_ARRAY              = 0x8079,
+        GL_VERTEX_ARRAY_SIZE            = 0x807A,
+        GL_VERTEX_ARRAY_TYPE            = 0x807B,
+        GL_VERTEX_ARRAY_STRIDE          = 0x807C,
+        GL_VERTEX_ARRAY_COUNT           = 0x807D,
+        GL_NORMAL_ARRAY_TYPE            = 0x807E,
+        GL_NORMAL_ARRAY_STRIDE          = 0x807F,
+        GL_NORMAL_ARRAY_COUNT           = 0x8080,
+        GL_COLOR_ARRAY_SIZE             = 0x8081,
+        GL_COLOR_ARRAY_TYPE             = 0x8082,
+        GL_COLOR_ARRAY_STRIDE           = 0x8083,
+        GL_COLOR_ARRAY_COUNT            = 0x8084,
+        GL_INDEX_ARRAY_TYPE             = 0x8085,
+        GL_INDEX_ARRAY_STRIDE           = 0x8086,
+        GL_INDEX_ARRAY_COUNT            = 0x8087,
+        GL_TEXTURE_COORD_ARRAY_SIZE     = 0x8088,
+        GL_TEXTURE_COORD_ARRAY_TYPE     = 0x8089,
+        GL_TEXTURE_COORD_ARRAY_STRIDE   = 0x808A,
+        GL_TEXTURE_COORD_ARRAY_COUNT    = 0x808B,
+        GL_EDGE_FLAG_ARRAY_STRIDE       = 0x808C,
+        GL_EDGE_FLAG_ARRAY_COUNT        = 0x808D,
+        GL_VERTEX_ARRAY_POINTER         = 0x808E,
+        GL_NORMAL_ARRAY_POINTER         = 0x808F,
+        GL_COLOR_ARRAY_POINTER          = 0x8090,
+        GL_INDEX_ARRAY_POINTER          = 0x8091,
+        GL_TEXTURE_COORD_ARRAY_POINTER  = 0x8092,
+        GL_EDGE_FLAG_ARRAY_POINTER      = 0x8093,
+        GL_V2F                          = 0x2A20,
+        GL_V3F                          = 0x2A21,
+        GL_C4UB_V2F                     = 0x2A22,
+        GL_C4UB_V3F                     = 0x2A23,
+        GL_C3F_V3F                      = 0x2A24,
+        GL_N3F_V3F                      = 0x2A25,
+        GL_C4F_N3F_V3F                  = 0x2A26,
+        GL_T2F_V3F                      = 0x2A27,
+        GL_T4F_V4F                      = 0x2A28,
+        GL_T2F_C4UB_V3F                 = 0x2A29,
+        GL_T2F_C3F_V3F                  = 0x2A2A,
+        GL_T2F_N3F_V3F                  = 0x2A2B,
+        GL_T2F_C4F_N3F_V3F              = 0x2A2C,
+        GL_T4F_C4F_N3F_V4F              = 0x2A2D,
+        /* Matrix Mode */
+        GL_MATRIX_MODE                  = 0x0BA0,
+        GL_MODELVIEW                    = 0x1700,
+        GL_PROJECTION                   = 0x1701,
+        GL_TEXTURE                      = 0x1702,
+        /* Points */
+        GL_POINT_SMOOTH                 = 0x0B10,
+        GL_POINT_SIZE                   = 0x0B11,
+        GL_POINT_SIZE_GRANULARITY       = 0x0B13,
+        GL_POINT_SIZE_RANGE             = 0x0B12,
+        /* Lines */
+        GL_LINE_SMOOTH                  = 0x0B20,
+        GL_LINE_STIPPLE                 = 0x0B24,
+        GL_LINE_STIPPLE_PATTERN         = 0x0B25,
+        GL_LINE_STIPPLE_REPEAT          = 0x0B26,
+        GL_LINE_WIDTH                   = 0x0B21,
+        GL_LINE_WIDTH_GRANULARITY       = 0x0B23,
+        GL_LINE_WIDTH_RANGE             = 0x0B22,
+        /* Polygons */
+        GL_POINT                        = 0x1B00,
+        GL_LINE                         = 0x1B01,
+        GL_FILL                         = 0x1B02,
+        GL_CCW                          = 0x0901,
+        GL_CW                           = 0x0900,
+        GL_FRONT                        = 0x0404,
+        GL_BACK                         = 0x0405,
+        GL_CULL_FACE                    = 0x0B44,
+        GL_CULL_FACE_MODE               = 0x0B45,
+        GL_POLYGON_SMOOTH               = 0x0B41,
+        GL_POLYGON_STIPPLE              = 0x0B42,
+        GL_FRONT_FACE                   = 0x0B46,
+        GL_POLYGON_MODE                 = 0x0B40,
+        GL_POLYGON_OFFSET_FACTOR        = 0x3038,
+        GL_POLYGON_OFFSET_UNITS         = 0x2A00,
+        GL_POLYGON_OFFSET_POINT         = 0x2A01,
+        GL_POLYGON_OFFSET_LINE          = 0x2A02,
+        GL_POLYGON_OFFSET_FILL          = 0x8037,
+        /* Display Lists */
+        GL_COMPILE                      = 0x1300,
+        GL_COMPILE_AND_EXECUTE          = 0x1301,
+        GL_LIST_BASE                    = 0x0B32,
+        GL_LIST_INDEX                   = 0x0B33,
+        GL_LIST_MODE                    = 0x0B30,
+        /* Depth buffer */
+        GL_NEVER                        = 0x0200,
+        GL_LESS                         = 0x0201,
+        GL_GEQUAL                       = 0x0206,
+        GL_LEQUAL                       = 0x0203,
+        GL_GREATER                      = 0x0204,
+        GL_NOTEQUAL                     = 0x0205,
+        GL_EQUAL                        = 0x0202,
+        GL_ALWAYS                       = 0x0207,
+        GL_DEPTH_TEST                   = 0x0B71,
+        GL_DEPTH_BITS                   = 0x0D56,
+        GL_DEPTH_CLEAR_VALUE            = 0x0B73,
+        GL_DEPTH_FUNC                   = 0x0B74,
+        GL_DEPTH_RANGE                  = 0x0B70,
+        GL_DEPTH_WRITEMASK              = 0x0B72,
+        GL_DEPTH_COMPONENT              = 0x1902,
+        /* Lighting */
+        GL_LIGHTING                     = 0x0B50,
+        GL_LIGHT0                       = 0x4000,
+        GL_LIGHT1                       = 0x4001,
+        GL_LIGHT2                       = 0x4002,
+        GL_LIGHT3                       = 0x4003,
+        GL_LIGHT4                       = 0x4004,
+        GL_LIGHT5                       = 0x4005,
+        GL_LIGHT6                       = 0x4006,
+        GL_LIGHT7                       = 0x4007,
+        GL_SPOT_EXPONENT                = 0x1205,
+        GL_SPOT_CUTOFF                  = 0x1206,
+        GL_CONSTANT_ATTENUATION         = 0x1207,
+        GL_LINEAR_ATTENUATION           = 0x1208,
+        GL_QUADRATIC_ATTENUATION        = 0x1209,
+        GL_AMBIENT                      = 0x1200,
+        GL_DIFFUSE                      = 0x1201,
+        GL_SPECULAR                     = 0x1202,
+        GL_SHININESS                    = 0x1601,
+        GL_EMISSION                     = 0x1600,
+        GL_POSITION                     = 0x1203,
+        GL_SPOT_DIRECTION               = 0x1204,
+        GL_AMBIENT_AND_DIFFUSE          = 0x1602,
+        GL_COLOR_INDEXES                = 0x1603,
+        GL_LIGHT_MODEL_TWO_SIDE         = 0x0B52,
+        GL_LIGHT_MODEL_LOCAL_VIEWER     = 0x0B51,
+        GL_LIGHT_MODEL_AMBIENT          = 0x0B53,
+        GL_FRONT_AND_BACK               = 0x0408,
+        GL_SHADE_MODEL                  = 0x0B54,
+        GL_FLAT                         = 0x1D00,
+        GL_SMOOTH                       = 0x1D01,
+        GL_COLOR_MATERIAL               = 0x0B57,
+        GL_COLOR_MATERIAL_FACE          = 0x0B55,
+        GL_COLOR_MATERIAL_PARAMETER     = 0x0B56,
+        GL_NORMALIZE                    = 0x0BA1,
+        /* User clipping planes */
+        GL_CLIP_PLANE0                  = 0x3000,
+        GL_CLIP_PLANE1                  = 0x3001,
+        GL_CLIP_PLANE2                  = 0x3002,
+        GL_CLIP_PLANE3                  = 0x3003,
+        GL_CLIP_PLANE4                  = 0x3004,
+        GL_CLIP_PLANE5                  = 0x3005,
+        /* Accumulation buffer */
+        GL_ACCUM_RED_BITS               = 0x0D58,
+        GL_ACCUM_GREEN_BITS             = 0x0D59,
+        GL_ACCUM_BLUE_BITS              = 0x0D5A,
+        GL_ACCUM_ALPHA_BITS             = 0x0D5B,
+        GL_ACCUM_CLEAR_VALUE            = 0x0B80,
+        GL_ACCUM                        = 0x0100,
+        GL_ADD                          = 0x0104,
+        GL_LOAD                         = 0x0101,
+        GL_MULT                         = 0x0103,
+        GL_RETURN                       = 0x0102,
+        /* Alpha testing */
+        GL_ALPHA_TEST                   = 0x0BC0,
+        GL_ALPHA_TEST_REF               = 0x0BC2,
+        GL_ALPHA_TEST_FUNC              = 0x0BC1,
+        /* Blending */
+        GL_BLEND                        = 0x0BE2,
+        GL_BLEND_SRC                    = 0x0BE1,
+        GL_BLEND_DST                    = 0x0BE0,
+        GL_ZERO                         = 0,
+        GL_ONE                          = 1,
+        GL_SRC_COLOR                    = 0x0300,
+        GL_ONE_MINUS_SRC_COLOR          = 0x0301,
+        GL_DST_COLOR                    = 0x0306,
+        GL_ONE_MINUS_DST_COLOR          = 0x0307,
+        GL_SRC_ALPHA                    = 0x0302,
+        GL_ONE_MINUS_SRC_ALPHA          = 0x0303,
+        GL_DST_ALPHA                    = 0x0304,
+        GL_ONE_MINUS_DST_ALPHA          = 0x0305,
+        GL_SRC_ALPHA_SATURATE           = 0x0308,
+        GL_CONSTANT_COLOR               = 0x8001,
+        GL_ONE_MINUS_CONSTANT_COLOR     = 0x8002,
+        GL_CONSTANT_ALPHA               = 0x8003,
+        GL_ONE_MINUS_CONSTANT_ALPHA     = 0x8004,
+        /* Render Mode */
+        GL_FEEDBACK                     = 0x1C01,
+        GL_RENDER                       = 0x1C00,
+        GL_SELECT                       = 0x1C02,
+        /* Feedback */
+        GL_2D                           = 0x0600,
+        GL_3D                           = 0x0601,
+        GL_3D_COLOR                     = 0x0602,
+        GL_3D_COLOR_TEXTURE             = 0x0603,
+        GL_4D_COLOR_TEXTURE             = 0x0604,
+        GL_POINT_TOKEN                  = 0x0701,
+        GL_LINE_TOKEN                   = 0x0702,
+        GL_LINE_RESET_TOKEN             = 0x0707,
+        GL_POLYGON_TOKEN                = 0x0703,
+        GL_BITMAP_TOKEN                 = 0x0704,
+        GL_DRAW_PIXEL_TOKEN             = 0x0705,
+        GL_COPY_PIXEL_TOKEN             = 0x0706,
+        GL_PASS_THROUGH_TOKEN           = 0x0700,
+        /* Fog */
+        GL_FOG                          = 0x0B60,
+        GL_FOG_MODE                     = 0x0B65,
+        GL_FOG_DENSITY                  = 0x0B62,
+        GL_FOG_COLOR                    = 0x0B66,
+        GL_FOG_INDEX                    = 0x0B61,
+        GL_FOG_START                    = 0x0B63,
+        GL_FOG_END                      = 0x0B64,
+        GL_LINEAR                       = 0x2601,
+        GL_EXP                          = 0x0800,
+        GL_EXP2                         = 0x0801,
+        /* Logic Ops */
+        GL_LOGIC_OP                     = 0x0BF1,
+        GL_LOGIC_OP_MODE                = 0x0BF0,
+        GL_CLEAR                        = 0x1500,
+        GL_SET                          = 0x150F,
+        GL_COPY                         = 0x1503,
+        GL_COPY_INVERTED                = 0x150C,
+        GL_NOOP                         = 0x1505,
+        GL_INVERT                       = 0x150A,
+        GL_AND                          = 0x1501,
+        GL_NAND                         = 0x150E,
+        GL_OR                           = 0x1507,
+        GL_NOR                          = 0x1508,
+        GL_XOR                          = 0x1506,
+        GL_EQUIV                        = 0x1509,
+        GL_AND_REVERSE                  = 0x1502,
+        GL_AND_INVERTED                 = 0x1504,
+        GL_OR_REVERSE                   = 0x150B,
+        GL_OR_INVERTED                  = 0x150D,
+        /* Stencil */
+        GL_STENCIL_TEST                 = 0x0B90,
+        GL_STENCIL_WRITEMASK            = 0x0B98,
+        GL_STENCIL_BITS                 = 0x0D57,
+        GL_STENCIL_FUNC                 = 0x0B92,
+        GL_STENCIL_VALUE_MASK           = 0x0B93,
+        GL_STENCIL_REF                  = 0x0B97,
+        GL_STENCIL_FAIL                 = 0x0B94,
+        GL_STENCIL_PASS_DEPTH_PASS      = 0x0B96,
+        GL_STENCIL_PASS_DEPTH_FAIL      = 0x0B95,
+        GL_STENCIL_CLEAR_VALUE          = 0x0B91,
+        GL_STENCIL_INDEX                = 0x1901,
+        GL_KEEP                         = 0x1E00,
+        GL_REPLACE                      = 0x1E01,
+        GL_INCR                         = 0x1E02,
+        GL_DECR                         = 0x1E03,
+        /* Buffers, Pixel Drawing/Reading */
+        GL_NONE                         = 0,
+        GL_LEFT                         = 0x0406,
+        GL_RIGHT                        = 0x0407,
+        /*GL_FRONT                      = 0x0404, */
+        /*GL_BACK                       = 0x0405, */
+        /*GL_FRONT_AND_BACK             = 0x0408, */
+        GL_FRONT_LEFT                   = 0x0400,
+        GL_FRONT_RIGHT                  = 0x0401,
+        GL_BACK_LEFT                    = 0x0402,
+        GL_BACK_RIGHT                   = 0x0403,
+        GL_AUX0                         = 0x0409,
+        GL_AUX1                         = 0x040A,
+        GL_AUX2                         = 0x040B,
+        GL_AUX3                         = 0x040C,
+        GL_COLOR_INDEX                  = 0x1900,
+        GL_RED                          = 0x1903,
+        GL_GREEN                        = 0x1904,
+        GL_BLUE                         = 0x1905,
+        GL_ALPHA                        = 0x1906,
+        GL_LUMINANCE                    = 0x1909,
+        GL_LUMINANCE_ALPHA              = 0x190A,
+        GL_ALPHA_BITS                   = 0x0D55,
+        GL_RED_BITS                     = 0x0D52,
+        GL_GREEN_BITS                   = 0x0D53,
+        GL_BLUE_BITS                    = 0x0D54,
+        GL_INDEX_BITS                   = 0x0D51,
+        GL_SUBPIXEL_BITS                = 0x0D50,
+        GL_AUX_BUFFERS                  = 0x0C00,
+        GL_READ_BUFFER                  = 0x0C02,
+        GL_DRAW_BUFFER                  = 0x0C01,
+        GL_DOUBLEBUFFER                 = 0x0C32,
+        GL_STEREO                       = 0x0C33,
+        GL_BITMAP                       = 0x1A00,
+        GL_COLOR                        = 0x1800,
+        GL_DEPTH                        = 0x1801,
+        GL_STENCIL                      = 0x1802,
+        GL_DITHER                       = 0x0BD0,
+        GL_RGB                          = 0x1907,
+        GL_RGBA                         = 0x1908,
+        /* Implementation limits */
+        GL_MAX_LIST_NESTING             = 0x0B31,
+        GL_MAX_ATTRIB_STACK_DEPTH       = 0x0D35,
+        GL_MAX_MODELVIEW_STACK_DEPTH    = 0x0D36,
+        GL_MAX_NAME_STACK_DEPTH         = 0x0D37,
+        GL_MAX_PROJECTION_STACK_DEPTH   = 0x0D38,
+        GL_MAX_TEXTURE_STACK_DEPTH      = 0x0D39,
+        GL_MAX_EVAL_ORDER               = 0x0D30,
+        GL_MAX_LIGHTS                   = 0x0D31,
+        GL_MAX_CLIP_PLANES              = 0x0D32,
+        GL_MAX_TEXTURE_SIZE             = 0x0D33,
+        GL_MAX_PIXEL_MAP_TABLE          = 0x0D34,
+        GL_MAX_VIEWPORT_DIMS            = 0x0D3A,
+        GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B,
+        /* Gets */
+        GL_ATTRIB_STACK_DEPTH           = 0x0BB0,
+        GL_COLOR_CLEAR_VALUE            = 0x0C22,
+        GL_COLOR_WRITEMASK              = 0x0C23,
+        GL_CURRENT_INDEX                = 0x0B01,
+        GL_CURRENT_COLOR                = 0x0B00,
+        GL_CURRENT_NORMAL               = 0x0B02,
+        GL_CURRENT_RASTER_COLOR         = 0x0B04,
+        GL_CURRENT_RASTER_DISTANCE      = 0x0B09,
+        GL_CURRENT_RASTER_INDEX         = 0x0B05,
+        GL_CURRENT_RASTER_POSITION      = 0x0B07,
+        GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
+        GL_CURRENT_RASTER_POSITION_VALID = 0x0B08,
+        GL_CURRENT_TEXTURE_COORDS       = 0x0B03,
+        GL_INDEX_CLEAR_VALUE            = 0x0C20,
+        GL_INDEX_MODE                   = 0x0C30,
+        GL_INDEX_WRITEMASK              = 0x0C21,
+        GL_MODELVIEW_MATRIX             = 0x0BA6,
+        GL_MODELVIEW_STACK_DEPTH        = 0x0BA3,
+        GL_NAME_STACK_DEPTH             = 0x0D70,
+        GL_PROJECTION_MATRIX            = 0x0BA7,
+        GL_PROJECTION_STACK_DEPTH       = 0x0BA4,
+        GL_RENDER_MODE                  = 0x0C40,
+        GL_RGBA_MODE                    = 0x0C31,
+        GL_TEXTURE_MATRIX               = 0x0BA8,
+        GL_TEXTURE_STACK_DEPTH          = 0x0BA5,
+        GL_VIEWPORT                     = 0x0BA2,
+        /* Evaluators */
+        GL_AUTO_NORMAL                  = 0x0D80,
+        GL_MAP1_COLOR_4                 = 0x0D90,
+        GL_MAP1_GRID_DOMAIN             = 0x0DD0,
+        GL_MAP1_GRID_SEGMENTS           = 0x0DD1,
+        GL_MAP1_INDEX                   = 0x0D91,
+        GL_MAP1_NORMAL                  = 0x0D92,
+        GL_MAP1_TEXTURE_COORD_1         = 0x0D93,
+        GL_MAP1_TEXTURE_COORD_2         = 0x0D94,
+        GL_MAP1_TEXTURE_COORD_3         = 0x0D95,
+        GL_MAP1_TEXTURE_COORD_4         = 0x0D96,
+        GL_MAP1_VERTEX_3                = 0x0D97,
+        GL_MAP1_VERTEX_4                = 0x0D98,
+        GL_MAP2_COLOR_4                 = 0x0DB0,
+        GL_MAP2_GRID_DOMAIN             = 0x0DD2,
+        GL_MAP2_GRID_SEGMENTS           = 0x0DD3,
+        GL_MAP2_INDEX                   = 0x0DB1,
+        GL_MAP2_NORMAL                  = 0x0DB2,
+        GL_MAP2_TEXTURE_COORD_1         = 0x0DB3,
+        GL_MAP2_TEXTURE_COORD_2         = 0x0DB4,
+        GL_MAP2_TEXTURE_COORD_3         = 0x0DB5,
+        GL_MAP2_TEXTURE_COORD_4         = 0x0DB6,
+        GL_MAP2_VERTEX_3                = 0x0DB7,
+        GL_MAP2_VERTEX_4                = 0x0DB8,
+        GL_COEFF                        = 0x0A00,
+        GL_DOMAIN                       = 0x0A02,
+        GL_ORDER                        = 0x0A01,
+        /* Hints */
+        GL_FOG_HINT                     = 0x0C54,
+        GL_LINE_SMOOTH_HINT             = 0x0C52,
+        GL_PERSPECTIVE_CORRECTION_HINT  = 0x0C50,
+        GL_POINT_SMOOTH_HINT            = 0x0C51,
+        GL_POLYGON_SMOOTH_HINT          = 0x0C53,
+        GL_DONT_CARE                    = 0x1100,
+        GL_FASTEST                      = 0x1101,
+        GL_NICEST                       = 0x1102,
+        /* Scissor box */
+        GL_SCISSOR_TEST                 = 0x0C11,
+        GL_SCISSOR_BOX                  = 0x0C10,
+        /* Pixel Mode / Transfer */
+        GL_MAP_COLOR                    = 0x0D10,
+        GL_MAP_STENCIL                  = 0x0D11,
+        GL_INDEX_SHIFT                  = 0x0D12,
+        GL_INDEX_OFFSET                 = 0x0D13,
+        GL_RED_SCALE                    = 0x0D14,
+        GL_RED_BIAS                     = 0x0D15,
+        GL_GREEN_SCALE                  = 0x0D18,
+        GL_GREEN_BIAS                   = 0x0D19,
+        GL_BLUE_SCALE                   = 0x0D1A,
+        GL_BLUE_BIAS                    = 0x0D1B,
+        GL_ALPHA_SCALE                  = 0x0D1C,
+        GL_ALPHA_BIAS                   = 0x0D1D,
+        GL_DEPTH_SCALE                  = 0x0D1E,
+        GL_DEPTH_BIAS                   = 0x0D1F,
+        GL_PIXEL_MAP_S_TO_S_SIZE        = 0x0CB1,
+        GL_PIXEL_MAP_I_TO_I_SIZE        = 0x0CB0,
+        GL_PIXEL_MAP_I_TO_R_SIZE        = 0x0CB2,
+        GL_PIXEL_MAP_I_TO_G_SIZE        = 0x0CB3,
+        GL_PIXEL_MAP_I_TO_B_SIZE        = 0x0CB4,
+        GL_PIXEL_MAP_I_TO_A_SIZE        = 0x0CB5,
+        GL_PIXEL_MAP_R_TO_R_SIZE        = 0x0CB6,
+        GL_PIXEL_MAP_G_TO_G_SIZE        = 0x0CB7,
+        GL_PIXEL_MAP_B_TO_B_SIZE        = 0x0CB8,
+        GL_PIXEL_MAP_A_TO_A_SIZE        = 0x0CB9,
+        GL_PIXEL_MAP_S_TO_S             = 0x0C71,
+        GL_PIXEL_MAP_I_TO_I             = 0x0C70,
+        GL_PIXEL_MAP_I_TO_R             = 0x0C72,
+        GL_PIXEL_MAP_I_TO_G             = 0x0C73,
+        GL_PIXEL_MAP_I_TO_B             = 0x0C74,
+        GL_PIXEL_MAP_I_TO_A             = 0x0C75,
+        GL_PIXEL_MAP_R_TO_R             = 0x0C76,
+        GL_PIXEL_MAP_G_TO_G             = 0x0C77,
+        GL_PIXEL_MAP_B_TO_B             = 0x0C78,
+        GL_PIXEL_MAP_A_TO_A             = 0x0C79,
+        GL_PACK_ALIGNMENT               = 0x0D05,
+        GL_PACK_LSB_FIRST               = 0x0D01,
+        GL_PACK_ROW_LENGTH              = 0x0D02,
+        GL_PACK_SKIP_PIXELS             = 0x0D04,
+        GL_PACK_SKIP_ROWS               = 0x0D03,
+        GL_PACK_SWAP_BYTES              = 0x0D00,
+        GL_UNPACK_ALIGNMENT             = 0x0CF5,
+        GL_UNPACK_LSB_FIRST             = 0x0CF1,
+        GL_UNPACK_ROW_LENGTH            = 0x0CF2,
+        GL_UNPACK_SKIP_PIXELS           = 0x0CF4,
+        GL_UNPACK_SKIP_ROWS             = 0x0CF3,
+        GL_UNPACK_SWAP_BYTES            = 0x0CF0,
+        GL_ZOOM_X                       = 0x0D16,
+        GL_ZOOM_Y                       = 0x0D17,
+        /* Texture mapping */
+        GL_TEXTURE_ENV                  = 0x2300,
+        GL_TEXTURE_ENV_MODE             = 0x2200,
+        GL_TEXTURE_1D                   = 0x0DE0,
+        GL_TEXTURE_2D                   = 0x0DE1,
+        GL_TEXTURE_WRAP_S               = 0x2802,
+        GL_TEXTURE_WRAP_T               = 0x2803,
+        GL_TEXTURE_MAG_FILTER           = 0x2800,
+        GL_TEXTURE_MIN_FILTER           = 0x2801,
+        GL_TEXTURE_ENV_COLOR            = 0x2201,
+        GL_TEXTURE_GEN_S                = 0x0C60,
+        GL_TEXTURE_GEN_T                = 0x0C61,
+        GL_TEXTURE_GEN_MODE             = 0x2500,
+        GL_TEXTURE_BORDER_COLOR         = 0x1004,
+        GL_TEXTURE_WIDTH                = 0x1000,
+        GL_TEXTURE_HEIGHT               = 0x1001,
+        GL_TEXTURE_BORDER               = 0x1005,
+        GL_TEXTURE_COMPONENTS           = 0x1003,
+        GL_NEAREST_MIPMAP_NEAREST       = 0x2700,
+        GL_NEAREST_MIPMAP_LINEAR        = 0x2702,
+        GL_LINEAR_MIPMAP_NEAREST        = 0x2701,
+        GL_LINEAR_MIPMAP_LINEAR         = 0x2703,
+        GL_OBJECT_LINEAR                = 0x2401,
+        GL_OBJECT_PLANE                 = 0x2501,
+        GL_EYE_LINEAR                   = 0x2400,
+        GL_EYE_PLANE                    = 0x2502,
+        GL_SPHERE_MAP                   = 0x2402,
+        GL_DECAL                        = 0x2101,
+        GL_MODULATE                     = 0x2100,
+        GL_NEAREST                      = 0x2600,
+        GL_REPEAT                       = 0x2901,
+        GL_CLAMP                        = 0x2900,
+        GL_S                            = 0x2000,
+        GL_T                            = 0x2001,
+        GL_R                            = 0x2002,
+        GL_Q                            = 0x2003,
+        GL_TEXTURE_GEN_R                = 0x0C62,
+        GL_TEXTURE_GEN_Q                = 0x0C63,
+        GL_PROXY_TEXTURE_1D             = 0x8063,
+        GL_PROXY_TEXTURE_2D             = 0x8064,
+        GL_TEXTURE_PRIORITY             = 0x8066,
+        GL_TEXTURE_RESIDENT             = 0x8067,
+        GL_TEXTURE_1D_BINDING           = 0x8068,
+        GL_TEXTURE_2D_BINDING           = 0x8069,
+        /* Internal texture formats */
+        GL_ALPHA4                       = 0x803B,
+        GL_ALPHA8                       = 0x803C,
+        GL_ALPHA12                      = 0x803D,
+        GL_ALPHA16                      = 0x803E,
+        GL_LUMINANCE4                   = 0x803F,
+        GL_LUMINANCE8                   = 0x8040,
+        GL_LUMINANCE12                  = 0x8041,
+        GL_LUMINANCE16                  = 0x8042,
+        GL_LUMINANCE4_ALPHA4            = 0x8043,
+        GL_LUMINANCE6_ALPHA2            = 0x8044,
+        GL_LUMINANCE8_ALPHA8            = 0x8045,
+        GL_LUMINANCE12_ALPHA4           = 0x8046,
+        GL_LUMINANCE12_ALPHA12          = 0x8047,
+        GL_LUMINANCE16_ALPHA16          = 0x8048,
+        GL_INTENSITY                    = 0x8049,
+        GL_INTENSITY4                   = 0x804A,
+        GL_INTENSITY8                   = 0x804B,
+        GL_INTENSITY12                  = 0x804C,
+        GL_INTENSITY16                  = 0x804D,
+        GL_R3_G3_B2                     = 0x2A10,
+        GL_RGB4                         = 0x804F,
+        GL_RGB5                         = 0x8050,
+        GL_RGB8                         = 0x8051,
+        GL_RGB10                        = 0x8052,
+        GL_RGB12                        = 0x8053,
+        GL_RGB16                        = 0x8054,
+        GL_RGBA2                        = 0x8055,
+        GL_RGBA4                        = 0x8056,
+        GL_RGB5_A1                      = 0x8057,
+        GL_RGBA8                        = 0x8058,
+        GL_RGB10_A2                     = 0x8059,
+        GL_RGBA12                       = 0x805A,
+        GL_RGBA16                       = 0x805B,
+        /* Utility */
+        GL_VENDOR                       = 0x1F00,
+        GL_RENDERER                     = 0x1F01,
+        GL_VERSION                      = 0x1F02,
+        GL_EXTENSIONS                   = 0x1F03,
+        /* Errors */
+        GL_INVALID_VALUE                = 0x0501,
+        GL_INVALID_ENUM                 = 0x0500,
+        GL_INVALID_OPERATION            = 0x0502,
+        GL_STACK_OVERFLOW               = 0x0503,
+        GL_STACK_UNDERFLOW              = 0x0504,
+        GL_OUT_OF_MEMORY                = 0x0505,
+        /*
+         * 1.0 Extensions
+         */
+        /* GL_EXT_blend_minmax and GL_EXT_blend_color */
+        GL_CONSTANT_COLOR_EXT           = 0x8001,
+        GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
+        GL_CONSTANT_ALPHA_EXT           = 0x8003,
+        GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
+        GL_BLEND_EQUATION_EXT           = 0x8009,
+        GL_MIN_EXT                      = 0x8007,
+        GL_MAX_EXT                      = 0x8008,
+        GL_FUNC_ADD_EXT                 = 0x8006,
+        GL_FUNC_SUBTRACT_EXT            = 0x800A,
+        GL_FUNC_REVERSE_SUBTRACT_EXT    = 0x800B,
+        GL_BLEND_COLOR_EXT              = 0x8005,
+        /* GL_EXT_polygon_offset */
+        GL_POLYGON_OFFSET_EXT           = 0x8037,
+        GL_POLYGON_OFFSET_FACTOR_EXT    = 0x8038,
+        GL_POLYGON_OFFSET_BIAS_EXT      = 0x8039,
+        /* GL_EXT_vertex_array */
+        GL_VERTEX_ARRAY_EXT             = 0x8074,
+        GL_NORMAL_ARRAY_EXT             = 0x8075,
+        GL_COLOR_ARRAY_EXT              = 0x8076,
+        GL_INDEX_ARRAY_EXT              = 0x8077,
+        GL_TEXTURE_COORD_ARRAY_EXT      = 0x8078,
+        GL_EDGE_FLAG_ARRAY_EXT          = 0x8079,
+        GL_VERTEX_ARRAY_SIZE_EXT        = 0x807A,
+        GL_VERTEX_ARRAY_TYPE_EXT        = 0x807B,
+        GL_VERTEX_ARRAY_STRIDE_EXT      = 0x807C,
+        GL_VERTEX_ARRAY_COUNT_EXT       = 0x807D,
+        GL_NORMAL_ARRAY_TYPE_EXT        = 0x807E,
+        GL_NORMAL_ARRAY_STRIDE_EXT      = 0x807F,
+        GL_NORMAL_ARRAY_COUNT_EXT       = 0x8080,
+        GL_COLOR_ARRAY_SIZE_EXT         = 0x8081,
+        GL_COLOR_ARRAY_TYPE_EXT         = 0x8082,
+        GL_COLOR_ARRAY_STRIDE_EXT       = 0x8083,
+        GL_COLOR_ARRAY_COUNT_EXT        = 0x8084,
+        GL_INDEX_ARRAY_TYPE_EXT         = 0x8085,
+        GL_INDEX_ARRAY_STRIDE_EXT       = 0x8086,
+        GL_INDEX_ARRAY_COUNT_EXT        = 0x8087,
+        GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
+        GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
+        GL_TEXTURE_COORD_ARRAY_STRIDE_EXT= 0x808A,
+        GL_TEXTURE_COORD_ARRAY_COUNT_EXT= 0x808B,
+        GL_EDGE_FLAG_ARRAY_STRIDE_EXT   = 0x808C,
+        GL_EDGE_FLAG_ARRAY_COUNT_EXT    = 0x808D,
+        GL_VERTEX_ARRAY_POINTER_EXT     = 0x808E,
+        GL_NORMAL_ARRAY_POINTER_EXT     = 0x808F,
+        GL_COLOR_ARRAY_POINTER_EXT      = 0x8090,
+        GL_INDEX_ARRAY_POINTER_EXT      = 0x8091,
+        GL_TEXTURE_COORD_ARRAY_POINTER_EXT= 0x8092,
+        GL_EDGE_FLAG_ARRAY_POINTER_EXT  = 0x8093
+};
+enum {
+        GL_CURRENT_BIT          = 0x00000001,
+        GL_POINT_BIT            = 0x00000002,
+        GL_LINE_BIT             = 0x00000004,
+        GL_POLYGON_BIT          = 0x00000008,
+        GL_POLYGON_STIPPLE_BIT  = 0x00000010,
+        GL_PIXEL_MODE_BIT       = 0x00000020,
+        GL_LIGHTING_BIT         = 0x00000040,
+        GL_FOG_BIT              = 0x00000080,
+        GL_DEPTH_BUFFER_BIT     = 0x00000100,
+        GL_ACCUM_BUFFER_BIT     = 0x00000200,
+        GL_STENCIL_BUFFER_BIT   = 0x00000400,
+        GL_VIEWPORT_BIT         = 0x00000800,
+        GL_TRANSFORM_BIT        = 0x00001000,
+        GL_ENABLE_BIT           = 0x00002000,
+        GL_COLOR_BUFFER_BIT     = 0x00004000,
+        GL_HINT_BIT             = 0x00008000,
+        GL_EVAL_BIT             = 0x00010000,
+        GL_LIST_BIT             = 0x00020000,
+        GL_TEXTURE_BIT          = 0x00040000,
+        GL_SCISSOR_BIT          = 0x00080000,
+        GL_ALL_ATTRIB_BITS      = 0x000fffff
+};
+/* some types */
+typedef int             GLenum;
+typedef void            GLvoid;
+typedef unsigned char   GLboolean;
+typedef signed char     GLbyte;         /* 1-byte signed */
+typedef short           GLshort;        /* 2-byte signed */
+typedef int             GLint;          /* 4-byte signed */
+typedef unsigned char   GLubyte;        /* 1-byte unsigned */
+typedef unsigned short  GLushort;       /* 2-byte unsigned */
+typedef unsigned int    GLuint;         /* 4-byte unsigned */
+typedef float           GLfloat;        /* single precision float */
+typedef double          GLdouble;       /* double precision float */
+typedef int GLsizei;
+/* functions */
+void glEnable(int code);
+void glDisable(int code);
+void glShadeModel(int mode);
+void glCullFace(int mode);
+void glPolygonMode(int face,int mode);
+void glBegin(int type);
+void glEnd(void);
+#define PROTO_GL1(name)                         \
+void gl ## name ## 1f(float);   \
+void gl ## name ## 1d(double);  \
+void gl ## name ## 1fv(float *);                \
+void gl ## name ## 1dv(double *);
+#define PROTO_GL2(name)                         \
+void gl ## name ## 2f(float ,float);    \
+void gl ## name ## 2d(double ,double);  \
+void gl ## name ## 2fv(float *);                \
+void gl ## name ## 2dv(double *);
+#define PROTO_GL3(name)                         \
+void gl ## name ## 3f(float ,float ,float);     \
+void gl ## name ## 3d(double ,double ,double);  \
+void gl ## name ## 3fv(float *);                \
+void gl ## name ## 3dv(double *);
+#define PROTO_GL4(name)                         \
+void gl ## name ## 4f(float ,float ,float, float );     \
+void gl ## name ## 4d(double ,double ,double, double ); \
+void gl ## name ## 4fv(float *);                \
+void gl ## name ## 4dv(double *);
+PROTO_GL2(Vertex)
+PROTO_GL3(Vertex)
+PROTO_GL4(Vertex)
+PROTO_GL3(Color)
+PROTO_GL4(Color)
+PROTO_GL3(Normal)
+PROTO_GL1(TexCoord)
+PROTO_GL2(TexCoord)
+PROTO_GL3(TexCoord)
+PROTO_GL4(TexCoord)
+void glEdgeFlag(int flag);
+/* matrix */
+void glMatrixMode(int mode);
+void glLoadMatrixf(const float *m);
+void glLoadIdentity(void);
+void glMultMatrixf(const float *m);
+void glPushMatrix(void);
+void glPopMatrix(void);
+void glRotatef(float angle,float x,float y,float z);
+void glTranslatef(float x,float y,float z);
+void glScalef(float x,float y,float z);
+void glViewport(int x,int y,int width,int height);
+void glFrustum(double left,double right,double bottom,double top,
+               double near_,double far_);
+/* lists */
+unsigned int glGenLists(int range);
+int glIsList(unsigned int list);
+void glNewList(unsigned int list,int mode);
+void glEndList(void);
+void glCallList(unsigned int list);
+/* clear */
+void glClear(int mask);
+void glClearColor(float r,float g,float b,float a);
+void glClearDepth(double depth);
+/* selection */
+int glRenderMode(int mode);
+void glSelectBuffer(int size,unsigned int *buf);
+void glInitNames(void);
+void glPushName(unsigned int name);
+void glPopName(void);
+void glLoadName(unsigned int name);
+/* textures */
+void glGenTextures(int n, unsigned int *textures);
+void glDeleteTextures(int n, const unsigned int *textures);
+void glBindTexture(int target,int texture);
+void glTexImage2D( int target, int level, int components,
+                    int width, int height, int border,
+                    int format, int type, void *pixels);
+void glTexEnvi(int target,int pname,int param);
+void glTexParameteri(int target,int pname,int param);
+void glPixelStorei(int pname,int param);
+/* lighting */
+void glMaterialfv(int mode,int type,float *v);
+void glMaterialf(int mode,int type,float v);
+void glColorMaterial(int mode,int type);
+void glLightfv(int light,int type,float *v);
+void glLightf(int light,int type,float v);
+void glLightModeli(int pname,int param);
+void glLightModelfv(int pname,float *param);
+/* misc */
+void glFlush(void);
+void glHint(int target,int mode);
+void glGetIntegerv(int pname,int *params);
+void glGetFloatv(int pname, float *v);
+void glFrontFace(int mode);
+/* opengl 1.2 arrays */
+void glEnableClientState(GLenum array);
+void glDisableClientState(GLenum array);
+void glArrayElement(GLint i);
+void glVertexPointer(GLint size, GLenum type, GLsizei stride,
+                     const GLvoid *pointer);
+void glColorPointer(GLint size, GLenum type, GLsizei stride,
+                     const GLvoid *pointer);
+void glNormalPointer(GLenum type, GLsizei stride,
+                      const GLvoid *pointer);
+void glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
+                       const GLvoid *pointer);
+/* opengl 1.2 polygon offset */
+void glPolygonOffset(GLfloat factor, GLfloat units);
+/* not implemented, just added to compile  */
+  /*
+inline void glPointSize(float) {}
+inline void glLineWidth(float) {}
+inline void glDeleteLists(int, int) {}
+inline void glDepthFunc(int) {}
+inline void glBlendFunc(int, int) {}
+inline void glTexEnvf(int, int, int) {}
+inline void glOrtho(float,float,float,float,float,float){}
+inline void glVertex2i(int,int) {}
+inline void glDepthMask(int) {}
+inline void glFogi(int, int) {}
+inline void glFogfv(int, const float*) {}
+inline void glFogf(int, float) {}
+inline void glRasterPos2f(float, float) {}
+inline void glPolygonStipple(void*) {}
+inline void glTexParameterf(int, int, int) {};
+  */
+/* non compatible functions */
+void glDebug(int mode);
+void glInit(void *zbuffer);
+void glClose(void);
+#ifdef __cplusplus
+}
+#endif
+#endif

 /programs/develop/libraries/TinyGL/include/GL/glu.h
 ,0 → 1,44
+#ifndef GLU_H
+#define GLU_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+void gluPerspective( GLdouble fovy, GLdouble aspect,
+                     GLdouble zNear, GLdouble zFar );
+void
+gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez,
+          GLdouble centerx, GLdouble centery, GLdouble centerz,
+          GLdouble upx, GLdouble upy, GLdouble upz);
+void drawTorus(float rc, int numc, float rt, int numt);
+typedef struct {
+  int draw_style;
+} GLUquadricObj;
+#define GLU_LINE 0
+GLUquadricObj* gluNewQuadric(void);
+void gluQuadricDrawStyle(GLUquadricObj *obj, int style);
+void gluSphere(GLUquadricObj *qobj,
+               float radius,int slices,int stacks);
+void gluCylinder( GLUquadricObj *qobj,
+                  GLdouble baseRadius, GLdouble topRadius, GLdouble height,
+                  GLint slices, GLint stacks );
+void gluDisk( GLUquadricObj *qobj,
+              GLdouble innerRadius, GLdouble outerRadius,
+              GLint slices, GLint loops );
+#ifdef __cplusplus
+}
+#endif
+#endif

 /programs/develop/libraries/TinyGL/include/kosgl.h
 ,0 → 1,28
+#ifndef KOSGL_H
+#define KOSGL_H
+#include <GL/gl.h>
+#include <GL/glu.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef void *KOSGLContext;
+extern KOSGLContext kosglCreateContext( KOSGLContext shareList, int flags );
+extern void kosglDestroyContext( KOSGLContext ctx1 );
+extern int kosglMakeCurrent( int win_x0, int win_y0,
+                             int win_x, int win_y,
+                             KOSGLContext ctx);
+extern void kosglSwapBuffers();
+#ifdef __cplusplus
+}
+#endif
+#endif

 /programs/develop/libraries/TinyGL/src/Makefile
 ,0 → 1,38
+include ../config.mk
+OBJS= clip.o vertex.o api.o list.o init.o matrix.o texture.o \
+      misc.o clear.o light.o select.o get.o error.o \
+      zbuffer.o zline.o zdither.o ztriangle.o \
+      zmath.o image_util.o msghandling.o \
+      arrays.o specbuf.o glu.o kosgl.o
+INCLUDES = -I$(TINYGL)/include -I$(MENUETDEV)/include
+LIB = libTinyGL.a
+all: $(LIB)
+$(LIB): $(OBJS)
+        rm -f $(LIB)
+        ar rcs $(LIB) $(OBJS)
+        copy /y $@ $(TINYGL)\lib
+        del $(LIB)
+clean:
+        rm -f *~ *.o *.a $(TINYGL)/$(LIB)
+.c.o:
+        $(CC) $(CFLAGS) $(INCLUDES) -c $*.c
+clip.o: zgl.h zfeatures.h
+vertex.o: zgl.h zfeatures.h
+light.o: zgl.h zfeatures.h
+matrix.o: zgl.h zfeatures.h
+list.o: zgl.h opinfo.h zfeatures.h
+arrays.c: zgl.h zfeatures.h
+specbuf.o: zgl.h zfeatures.h
+glx.o: zgl.h zfeatures.h
+nglx.o: zgl.h zfeatures.h
+zline.o: zgl.h zfeatures.h zline.h
+ztriangle.o: ztriangle.c ztriangle.h zgl.h zfeatures.h
+        $(CC) $(CFLAGS) $(INCLUDES) -c $*.c

/programs/develop/libraries/TinyGL/src/Tupfile.lua
0,0 → 1,7
if tup.getconfig("NO_GCC") ~= "" then return end
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../.." or tup.getconfig("HELPERDIR")
tup.include(HELPERDIR .. "/use_gcc.lua")
tup.include(HELPERDIR .. "/use_menuetlibc.lua")
INCLUDES = INCLUDES .. " -I../include"
compile_gcc("*.c")
tup.rule(OBJS, "kos32-ar rcs %o %f", {"../lib/libTinyGL.a", "../<>"})

 /programs/develop/libraries/TinyGL/src/api.c
 ,0 → 1,666
+#include "zgl.h"
+#include <stdio.h>
+/* glVertex */
+void glVertex4f(float x,float y,float z,float w)
+{
+  GLParam p[5];
+  p[0].op=OP_Vertex;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+  p[4].f=w;
+  gl_add_op(p);
+}
+void glVertex2f(float x,float y)
+{
+  glVertex4f(x,y,0,1);
+}
+void glVertex3f(float x,float y,float z)
+{
+  glVertex4f(x,y,z,1);
+}
+void glVertex3fv(float *v)
+{
+  glVertex4f(v[0],v[1],v[2],1);
+}
+/* glNormal */
+void glNormal3f(float x,float y,float z)
+{
+  GLParam p[4];
+  p[0].op=OP_Normal;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+  gl_add_op(p);
+}
+void glNormal3fv(float *v)
+{
+  glNormal3f(v[0],v[1],v[2]);
+}
+/* glColor */
+void glColor4f(float r,float g,float b,float a)
+{
+  GLParam p[8];
+  p[0].op=OP_Color;
+  p[1].f=b;
+  p[2].f=g;
+  p[3].f=r;
+  p[4].f=a;
+  /* direct convertion to integer to go faster if no shading */
+  RGBFtoRGBI(r,g,b,p[7].ui,p[6].ui,p[5].ui);
+  gl_add_op(p);
+}
+void glColor4fv(float *v)
+{
+  GLParam p[8];
+  p[0].op=OP_Color;
+  p[1].f=v[2];
+  p[2].f=v[1];
+  p[3].f=v[0];
+  p[4].f=v[3];
+  /* direct convertion to integer to go faster if no shading */
+  p[5].ui = (unsigned int) (v[2] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) +
+                            ZB_POINT_RED_MIN);
+  p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) +
+                            ZB_POINT_GREEN_MIN);
+  p[7].ui = (unsigned int) (v[0] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) +
+                            ZB_POINT_BLUE_MIN);
+  gl_add_op(p);
+}
+void glColor3f(float x,float y,float z)
+{
+  glColor4f(x,y,z,1);
+}
+void glColor3fv(float *v)
+{
+  glColor4f(v[0],v[1],v[2],1);
+}
+/* TexCoord */
+void glTexCoord4f(float s,float t,float r,float q)
+{
+  GLParam p[5];
+  p[0].op=OP_TexCoord;
+  p[1].f=s;
+  p[2].f=t;
+  p[3].f=r;
+  p[4].f=q;
+  gl_add_op(p);
+}
+void glTexCoord2f(float s,float t)
+{
+  glTexCoord4f(s,t,0,1);
+}
+void glTexCoord2fv(float *v)
+{
+  glTexCoord4f(v[0],v[1],0,1);
+}
+void glEdgeFlag(int flag)
+{
+  GLParam p[2];
+  p[0].op=OP_EdgeFlag;
+  p[1].i=flag;
+  gl_add_op(p);
+}
+/* misc */
+void glShadeModel(int mode)
+{
+  GLParam p[2];
+  assert(mode == GL_FLAT || mode == GL_SMOOTH);
+  p[0].op=OP_ShadeModel;
+  p[1].i=mode;
+  gl_add_op(p);
+}
+void glCullFace(int mode)
+{
+  GLParam p[2];
+  assert(mode == GL_BACK ||
+         mode == GL_FRONT ||
+         mode == GL_FRONT_AND_BACK);
+  p[0].op=OP_CullFace;
+  p[1].i=mode;
+  gl_add_op(p);
+}
+void glFrontFace(int mode)
+{
+  GLParam p[2];
+  assert(mode == GL_CCW || mode == GL_CW);
+  mode = (mode != GL_CCW);
+  p[0].op=OP_FrontFace;
+  p[1].i=mode;
+  gl_add_op(p);
+}
+void glPolygonMode(int face,int mode)
+{
+  GLParam p[3];
+  assert(face == GL_BACK ||
+         face == GL_FRONT ||
+         face == GL_FRONT_AND_BACK);
+  assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
+  p[0].op=OP_PolygonMode;
+  p[1].i=face;
+  p[2].i=mode;
+  gl_add_op(p);
+}
+/* glEnable / glDisable */
+void glEnable(int cap)
+{
+  GLParam p[3];
+  p[0].op=OP_EnableDisable;
+  p[1].i=cap;
+  p[2].i=1;
+  gl_add_op(p);
+}
+void glDisable(int cap)
+{
+  GLParam p[3];
+  p[0].op=OP_EnableDisable;
+  p[1].i=cap;
+  p[2].i=0;
+  gl_add_op(p);
+}
+/* glBegin / glEnd */
+void glBegin(int mode)
+{
+  GLParam p[2];
+  p[0].op=OP_Begin;
+  p[1].i=mode;
+  gl_add_op(p);
+}
+void glEnd(void)
+{
+  GLParam p[1];
+  p[0].op=OP_End;
+  gl_add_op(p);
+}
+/* matrix */
+void glMatrixMode(int mode)
+{
+  GLParam p[2];
+  p[0].op=OP_MatrixMode;
+  p[1].i=mode;
+  gl_add_op(p);
+}
+void glLoadMatrixf(const float *m)
+{
+  GLParam p[17];
+  int i;
+  p[0].op=OP_LoadMatrix;
+  for(i=0;i<16;i++) p[i+1].f=m[i];
+  gl_add_op(p);
+}
+void glLoadIdentity(void)
+{
+  GLParam p[1];
+  p[0].op=OP_LoadIdentity;
+  gl_add_op(p);
+}
+void glMultMatrixf(const float *m)
+{
+  GLParam p[17];
+  int i;
+  p[0].op=OP_MultMatrix;
+  for(i=0;i<16;i++) p[i+1].f=m[i];
+  gl_add_op(p);
+}
+void glPushMatrix(void)
+{
+  GLParam p[1];
+  p[0].op=OP_PushMatrix;
+  gl_add_op(p);
+}
+void glPopMatrix(void)
+{
+  GLParam p[1];
+  p[0].op=OP_PopMatrix;
+  gl_add_op(p);
+}
+void glRotatef(float angle,float x,float y,float z)
+{
+  GLParam p[5];
+  p[0].op=OP_Rotate;
+  p[1].f=angle;
+  p[2].f=x;
+  p[3].f=y;
+  p[4].f=z;
+  gl_add_op(p);
+}
+void glTranslatef(float x,float y,float z)
+{
+  GLParam p[4];
+  p[0].op=OP_Translate;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+  gl_add_op(p);
+}
+void glScalef(float x,float y,float z)
+{
+  GLParam p[4];
+  p[0].op=OP_Scale;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+  gl_add_op(p);
+}
+void glViewport(int x,int y,int width,int height)
+{
+  GLParam p[5];
+  p[0].op=OP_Viewport;
+  p[1].i=x;
+  p[2].i=y;
+  p[3].i=width;
+  p[4].i=height;
+  gl_add_op(p);
+}
+void glFrustum(double left,double right,double bottom,double top,
+               double near,double farv)
+{
+  GLParam p[7];
+  p[0].op=OP_Frustum;
+  p[1].f=left;
+  p[2].f=right;
+  p[3].f=bottom;
+  p[4].f=top;
+  p[5].f=near;
+  p[6].f=farv;
+  gl_add_op(p);
+}
+/* lightening */
+void glMaterialfv(int mode,int type,float *v)
+{
+  GLParam p[7];
+  int i,n;
+  assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
+  p[0].op=OP_Material;
+  p[1].i=mode;
+  p[2].i=type;
+  n=4;
+  if (type == GL_SHININESS) n=1;
+  p[3].f=v[2];
+  p[4].f=v[1];
+  p[5].f=v[0];
+  p[6].f=v[3];
+  for(i=n;i<4;i++) p[3+i].f=0;
+  gl_add_op(p);
+}
+void glMaterialf(int mode,int type,float v)
+{
+  GLParam p[7];
+  int i;
+  p[0].op=OP_Material;
+  p[1].i=mode;
+  p[2].i=type;
+  p[3].f=v;
+  for(i=0;i<3;i++) p[4+i].f=0;
+  gl_add_op(p);
+}
+void glColorMaterial(int mode,int type)
+{
+  GLParam p[3];
+  p[0].op=OP_ColorMaterial;
+  p[1].i=mode;
+  p[2].i=type;
+  gl_add_op(p);
+}
+void glLightfv(int light,int type,float *v)
+{
+  GLParam p[7];
+  int i;
+  p[0].op=OP_Light;
+  p[1].i=light;
+  p[2].i=type;
+  /* TODO: 3 composants ? */
+  for(i=0;i<4;i++) p[3+i].f=v[i];
+  gl_add_op(p);
+}
+void glLightf(int light,int type,float v)
+{
+  GLParam p[7];
+  int i;
+  p[0].op=OP_Light;
+  p[1].i=light;
+  p[2].i=type;
+  p[3].f=v;
+  for(i=0;i<3;i++) p[4+i].f=0;
+  gl_add_op(p);
+}
+void glLightModeli(int pname,int param)
+{
+  GLParam p[6];
+  int i;
+  p[0].op=OP_LightModel;
+  p[1].i=pname;
+  p[2].f=(float)param;
+  for(i=0;i<4;i++) p[3+i].f=0;
+  gl_add_op(p);
+}
+void glLightModelfv(int pname,float *param)
+{
+  GLParam p[6];
+  int i;
+  p[0].op=OP_LightModel;
+  p[1].i=pname;
+  for(i=0;i<4;i++) p[2+i].f=param[i];
+  gl_add_op(p);
+}
+/* clear */
+void glClear(int mask)
+{
+  GLParam p[2];
+  p[0].op=OP_Clear;
+  p[1].i=mask;
+  gl_add_op(p);
+}
+void glClearColor(float r,float g,float b,float a)
+{
+  GLParam p[5];
+  p[0].op=OP_ClearColor;
+  p[1].f=b;
+  p[2].f=g;
+  p[3].f=r;
+  p[4].f=a;
+  gl_add_op(p);
+}
+void glClearDepth(double depth)
+{
+  GLParam p[2];
+  p[0].op=OP_ClearDepth;
+  p[1].f=depth;
+  gl_add_op(p);
+}
+/* textures */
+void glTexImage2D( int target, int level, int components,
+                   int width, int height, int border,
+                   int format, int type, void *pixels)
+{
+  GLParam p[10];
+  p[0].op=OP_TexImage2D;
+  p[1].i=target;
+  p[2].i=level;
+  p[3].i=components;
+  p[4].i=width;
+  p[5].i=height;
+  p[6].i=border;
+  p[7].i=format;
+  p[8].i=type;
+  p[9].p=pixels;
+  gl_add_op(p);
+}
+void glBindTexture(int target,int texture)
+{
+  GLParam p[3];
+  p[0].op=OP_BindTexture;
+  p[1].i=target;
+  p[2].i=texture;
+  gl_add_op(p);
+}
+void glTexEnvi(int target,int pname,int param)
+{
+  GLParam p[8];
+  p[0].op=OP_TexEnv;
+  p[1].i=target;
+  p[2].i=pname;
+  p[3].i=param;
+  p[4].f=0;
+  p[5].f=0;
+  p[6].f=0;
+  p[7].f=0;
+  gl_add_op(p);
+}
+void glTexParameteri(int target,int pname,int param)
+{
+  GLParam p[8];
+  p[0].op=OP_TexParameter;
+  p[1].i=target;
+  p[2].i=pname;
+  p[3].i=param;
+  p[4].f=0;
+  p[5].f=0;
+  p[6].f=0;
+  p[7].f=0;
+  gl_add_op(p);
+}
+void glPixelStorei(int pname,int param)
+{
+  GLParam p[3];
+  p[0].op=OP_PixelStore;
+  p[1].i=pname;
+  p[2].i=param;
+  gl_add_op(p);
+}
+/* selection */
+void glInitNames(void)
+{
+  GLParam p[1];
+  p[0].op=OP_InitNames;
+  gl_add_op(p);
+}
+void glPushName(unsigned int name)
+{
+  GLParam p[2];
+  p[0].op=OP_PushName;
+  p[1].i=name;
+  gl_add_op(p);
+}
+void glPopName(void)
+{
+  GLParam p[1];
+  p[0].op=OP_PopName;
+  gl_add_op(p);
+}
+void glLoadName(unsigned int name)
+{
+  GLParam p[2];
+  p[0].op=OP_LoadName;
+  p[1].i=name;
+  gl_add_op(p);
+}
+void
+glPolygonOffset(GLfloat factor, GLfloat units)
+{
+  GLParam p[3];
+  p[0].op = OP_PolygonOffset;
+  p[1].f = factor;
+  p[2].f = units;
+}
+/* Special Functions */
+void glCallList(unsigned int list)
+{
+  GLParam p[2];
+  p[0].op=OP_CallList;
+  p[1].i=list;
+  gl_add_op(p);
+}
+void glFlush(void)
+{
+  /* nothing to do */
+}
+void glHint(int target,int mode)
+{
+  GLParam p[3];
+  p[0].op=OP_Hint;
+  p[1].i=target;
+  p[2].i=mode;
+  gl_add_op(p);
+}
+/* Non standard functions */
+void glDebug(int mode)
+{
+  GLContext *c=gl_get_context();
+  c->print_flag=mode;
+}

 /programs/develop/libraries/TinyGL/src/arrays.c
 ,0 → 1,206
+#include "zgl.h"
+/*#include <assert.h>*/
+#include <stdio.h>
+#define VERTEX_ARRAY   0x0001
+#define COLOR_ARRAY    0x0002
+#define NORMAL_ARRAY   0x0004
+#define TEXCOORD_ARRAY 0x0008
+void
+glopArrayElement(GLContext *c, GLParam *param)
+{
+  int i;
+  int states = c->client_states;
+  int idx = param[1].i;
+  if (states & COLOR_ARRAY) {
+    GLParam p[5];
+    int size = c->color_array_size;
+    i = idx * (size + c->color_array_stride);
+    p[1].f = c->color_array[i];
+    p[2].f = c->color_array[i+1];
+    p[3].f = c->color_array[i+2];
+    p[4].f = size > 3 ? c->color_array[i+3] : 1.0f;
+    glopColor(c, p);
+  }
+  if (states & NORMAL_ARRAY) {
+    i = idx * (3 + c->normal_array_stride);
+    c->current_normal.X = c->normal_array[i];
+    c->current_normal.Y = c->normal_array[i+1];
+    c->current_normal.Z = c->normal_array[i+2];
+    c->current_normal.Z = 0.0f;
+  }
+  if (states & TEXCOORD_ARRAY) {
+    int size = c->texcoord_array_size;
+    i = idx * (size + c->texcoord_array_stride);
+    c->current_tex_coord.X = c->texcoord_array[i];
+    c->current_tex_coord.Y = c->texcoord_array[i+1];
+    c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f;
+    c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f;
+  }
+  if (states & VERTEX_ARRAY) {
+    GLParam p[5];
+    int size = c->vertex_array_size;
+    i = idx * (size + c->vertex_array_stride);
+    p[1].f = c->vertex_array[i];
+    p[2].f = c->vertex_array[i+1];
+    p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f;
+    p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f;
+    glopVertex(c, p);
+  }
+}
+void
+glArrayElement(GLint i)
+{
+  GLParam p[2];
+  p[0].op = OP_ArrayElement;
+  p[1].i = i;
+  gl_add_op(p);
+}
+void
+glopEnableClientState(GLContext *c, GLParam *p)
+{
+  c->client_states |= p[1].i;
+}
+void
+glEnableClientState(GLenum array)
+{
+  GLParam p[2];
+  p[0].op = OP_EnableClientState;
+  switch(array) {
+  case GL_VERTEX_ARRAY:
+    p[1].i = VERTEX_ARRAY;
+    break;
+  case GL_NORMAL_ARRAY:
+    p[1].i = NORMAL_ARRAY;
+    break;
+  case GL_COLOR_ARRAY:
+    p[1].i = COLOR_ARRAY;
+    break;
+  case GL_TEXTURE_COORD_ARRAY:
+    p[1].i = TEXCOORD_ARRAY;
+    break;
+  default:
+    assert(0);
+    break;
+  }
+  gl_add_op(p);
+}
+void
+glopDisableClientState(GLContext *c, GLParam *p)
+{
+  c->client_states &= p[1].i;
+}
+void
+glDisableClientState(GLenum array)
+{
+  GLParam p[2];
+  p[0].op = OP_DisableClientState;
+  switch(array) {
+  case GL_VERTEX_ARRAY:
+    p[1].i = ~VERTEX_ARRAY;
+    break;
+  case GL_NORMAL_ARRAY:
+    p[1].i = ~NORMAL_ARRAY;
+    break;
+  case GL_COLOR_ARRAY:
+    p[1].i = ~COLOR_ARRAY;
+    break;
+  case GL_TEXTURE_COORD_ARRAY:
+    p[1].i = ~TEXCOORD_ARRAY;
+    break;
+  default:
+    assert(0);
+    break;
+  }
+  gl_add_op(p);
+}
+void
+glopVertexPointer(GLContext *c, GLParam *p)
+{
+  c->vertex_array_size = p[1].i;
+  c->vertex_array_stride = p[2].i;
+  c->vertex_array = p[3].p;
+}
+void
+glVertexPointer(GLint size, GLenum type, GLsizei stride,
+                const GLvoid *pointer)
+{
+  GLParam p[4];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_VertexPointer;
+  p[1].i = size;
+  p[2].i = stride;
+  p[3].p = (void*)pointer;
+  gl_add_op(p);
+}
+void
+glopColorPointer(GLContext *c, GLParam *p)
+{
+  c->color_array_size = p[1].i;
+  c->color_array_stride = p[2].i;
+  c->color_array = p[3].p;
+}
+void
+glColorPointer(GLint size, GLenum type, GLsizei stride,
+               const GLvoid *pointer)
+{
+  GLParam p[4];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_ColorPointer;
+  p[1].i = size;
+  p[2].i = stride;
+  p[3].p = (void*)pointer;
+  gl_add_op(p);
+}
+void
+glopNormalPointer(GLContext *c, GLParam *p)
+{
+  c->normal_array_stride = p[1].i;
+  c->normal_array = p[2].p;
+}
+void
+glNormalPointer(GLenum type, GLsizei stride,
+                const GLvoid *pointer)
+{
+  GLParam p[3];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_NormalPointer;
+  p[1].i = stride;
+  p[2].p = (void*)pointer;
+}
+void
+glopTexCoordPointer(GLContext *c, GLParam *p)
+{
+  c->texcoord_array_size = p[1].i;
+  c->texcoord_array_stride = p[2].i;
+  c->texcoord_array = p[3].p;
+}
+void
+glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
+                  const GLvoid *pointer)
+{
+  GLParam p[4];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_TexCoordPointer;
+  p[1].i = size;
+  p[2].i = stride;
+  p[3].p = (void*)pointer;
+}

 /programs/develop/libraries/TinyGL/src/clear.c
 ,0 → 1,30
+#include "zgl.h"
+void glopClearColor(GLContext *c,GLParam *p)
+{
+  c->clear_color.v[0]=p[1].f;
+  c->clear_color.v[1]=p[2].f;
+  c->clear_color.v[2]=p[3].f;
+  c->clear_color.v[3]=p[4].f;
+}
+void glopClearDepth(GLContext *c,GLParam *p)
+{
+  c->clear_depth=p[1].f;
+}
+void glopClear(GLContext *c,GLParam *p)
+{
+  int mask=p[1].i;
+  int z=0;
+  int r=(int)(c->clear_color.v[0]*65535);
+  int g=(int)(c->clear_color.v[1]*65535);
+  int b=(int)(c->clear_color.v[2]*65535);
+  /* TODO : correct value of Z */
+  ZB_clear(c->zb,mask & GL_DEPTH_BUFFER_BIT,z,
+           mask & GL_COLOR_BUFFER_BIT,r,g,b);
+}

 /programs/develop/libraries/TinyGL/src/clip.c
 ,0 → 1,450
+#include "zgl.h"
+/* fill triangle profile */
+/* #define PROFILE */
+#define CLIP_XMIN   (1<<0)
+#define CLIP_XMAX   (1<<1)
+#define CLIP_YMIN   (1<<2)
+#define CLIP_YMAX   (1<<3)
+#define CLIP_ZMIN   (1<<4)
+#define CLIP_ZMAX   (1<<5)
+void gl_transform_to_viewport(GLContext *c,GLVertex *v)
+{
+  float winv;
+  /* coordinates */
+  winv=1.0/v->pc.W;
+  v->zp.x= (int) ( v->pc.X * winv * c->viewport.scale.X
+                   + c->viewport.trans.X );
+  v->zp.y= (int) ( v->pc.Y * winv * c->viewport.scale.Y
+                   + c->viewport.trans.Y );
+  v->zp.z= (int) ( v->pc.Z * winv * c->viewport.scale.Z
+                   + c->viewport.trans.Z );
+  /* color */
+  if (c->lighting_enabled) {
+      v->zp.r=(int)(v->color.v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN)
+                    + ZB_POINT_RED_MIN);
+      v->zp.g=(int)(v->color.v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN)
+                    + ZB_POINT_GREEN_MIN);
+      v->zp.b=(int)(v->color.v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN)
+                    + ZB_POINT_BLUE_MIN);
+  } else {
+      /* no need to convert to integer if no lighting : take current color */
+      v->zp.r = c->longcurrent_color[0];
+      v->zp.g = c->longcurrent_color[1];
+      v->zp.b = c->longcurrent_color[2];
+  }
+  /* texture */
+  if (c->texture_2d_enabled) {
+    v->zp.s=(int)(v->tex_coord.X * (ZB_POINT_S_MAX - ZB_POINT_S_MIN)
+                  + ZB_POINT_S_MIN);
+    v->zp.t=(int)(v->tex_coord.Y * (ZB_POINT_T_MAX - ZB_POINT_T_MIN)
+                  + ZB_POINT_T_MIN);
+  }
+}
+static void gl_add_select1(GLContext *c,int z1,int z2,int z3)
+{
+  unsigned int min,max;
+  min=max=z1;
+  if (z2<min) min=z2;
+  if (z3<min) min=z3;
+  if (z2>max) max=z2;
+  if (z3>max) max=z3;
+  gl_add_select(c,0xffffffff-min,0xffffffff-max);
+}
+/* point */
+void gl_draw_point(GLContext *c,GLVertex *p0)
+{
+  if (p0->clip_code == 0) {
+    if (c->render_mode == GL_SELECT) {
+      gl_add_select(c,p0->zp.z,p0->zp.z);
+    } else {
+      ZB_plot(c->zb,&p0->zp);
+    }
+  }
+}
+/* line */
+static inline void interpolate(GLVertex *q,GLVertex *p0,GLVertex *p1,float t)
+{
+  q->pc.X=p0->pc.X+(p1->pc.X-p0->pc.X)*t;
+  q->pc.Y=p0->pc.Y+(p1->pc.Y-p0->pc.Y)*t;
+  q->pc.Z=p0->pc.Z+(p1->pc.Z-p0->pc.Z)*t;
+  q->pc.W=p0->pc.W+(p1->pc.W-p0->pc.W)*t;
+  q->color.v[0]=p0->color.v[0] + (p1->color.v[0]-p0->color.v[0])*t;
+  q->color.v[1]=p0->color.v[1] + (p1->color.v[1]-p0->color.v[1])*t;
+  q->color.v[2]=p0->color.v[2] + (p1->color.v[2]-p0->color.v[2])*t;
+}
+/*
+ * Line Clipping
+ */
+/* Line Clipping algorithm from 'Computer Graphics', Principles and
+   Practice */
+static inline int ClipLine1(float denom,float num,float *tmin,float *tmax)
+{
+  float t;
+  if (denom>0) {
+    t=num/denom;
+    if (t>*tmax) return 0;
+    if (t>*tmin) *tmin=t;
+  } else if (denom<0) {
+    t=num/denom;
+    if (t<*tmin) return 0;
+    if (t<*tmax) *tmax=t;
+  } else if (num>0) return 0;
+  return 1;
+}
+void gl_draw_line(GLContext *c,GLVertex *p1,GLVertex *p2)
+{
+  float dx,dy,dz,dw,x1,y1,z1,w1;
+  float tmin,tmax;
+  GLVertex q1,q2;
+  int cc1,cc2;
+  cc1=p1->clip_code;
+  cc2=p2->clip_code;
+  if ( (cc1 | cc2) == 0) {
+    if (c->render_mode == GL_SELECT) {
+      gl_add_select1(c,p1->zp.z,p2->zp.z,p2->zp.z);
+    } else {
+        if (c->depth_test)
+            ZB_line_z(c->zb,&p1->zp,&p2->zp);
+        else
+            ZB_line(c->zb,&p1->zp,&p2->zp);
+    }
+  } else if ( (cc1&cc2) != 0 ) {
+    return;
+  } else {
+    dx=p2->pc.X-p1->pc.X;
+    dy=p2->pc.Y-p1->pc.Y;
+    dz=p2->pc.Z-p1->pc.Z;
+    dw=p2->pc.W-p1->pc.W;
+    x1=p1->pc.X;
+    y1=p1->pc.Y;
+    z1=p1->pc.Z;
+    w1=p1->pc.W;
+    tmin=0;
+    tmax=1;
+    if (ClipLine1(dx+dw,-x1-w1,&tmin,&tmax) &&
+        ClipLine1(-dx+dw,x1-w1,&tmin,&tmax) &&
+        ClipLine1(dy+dw,-y1-w1,&tmin,&tmax) &&
+        ClipLine1(-dy+dw,y1-w1,&tmin,&tmax) &&
+        ClipLine1(dz+dw,-z1-w1,&tmin,&tmax) &&
+        ClipLine1(-dz+dw,z1-w1,&tmin,&tmax)) {
+      interpolate(&q1,p1,p2,tmin);
+      interpolate(&q2,p1,p2,tmax);
+      gl_transform_to_viewport(c,&q1);
+      gl_transform_to_viewport(c,&q2);
+      RGBFtoRGBI(q1.color.v[0],q1.color.v[1],q1.color.v[2],q1.zp.r,q1.zp.g,q1.zp.b);
+      RGBFtoRGBI(q2.color.v[0],q2.color.v[1],q2.color.v[2],q2.zp.r,q2.zp.g,q2.zp.b);
+      if (c->depth_test)
+          ZB_line_z(c->zb,&q1.zp,&q2.zp);
+      else
+          ZB_line(c->zb,&q1.zp,&q2.zp);
+    }
+  }
+}
+/* triangle */
+/*
+ * Clipping
+ */
+/* We clip the segment [a,b] against the 6 planes of the normal volume.
+ * We compute the point 'c' of intersection and the value of the parameter 't'
+ * of the intersection if x=a+t(b-a).
+ */
+#define clip_func(name,sign,dir,dir1,dir2) \
+static float name(V4 *c,V4 *a,V4 *b) \
+{\
+  float t,dX,dY,dZ,dW,den;\
+  dX = (b->X - a->X);\
+  dY = (b->Y - a->Y);\
+  dZ = (b->Z - a->Z);\
+  dW = (b->W - a->W);\
+  den = -(sign d ## dir) + dW;\
+  if (den == 0) t=0;\
+  else t = ( sign a->dir - a->W) / den;\
+  c->dir1 = a->dir1 + t * d ## dir1;\
+  c->dir2 = a->dir2 + t * d ## dir2;\
+  c->W = a->W + t * dW;\
+  c->dir = sign c->W;\
+  return t;\
+}
+clip_func(clip_xmin,-,X,Y,Z)
+clip_func(clip_xmax,+,X,Y,Z)
+clip_func(clip_ymin,-,Y,X,Z)
+clip_func(clip_ymax,+,Y,X,Z)
+clip_func(clip_zmin,-,Z,X,Y)
+clip_func(clip_zmax,+,Z,X,Y)
+float (*clip_proc[6])(V4 *,V4 *,V4 *)=  {
+    clip_xmin,clip_xmax,
+    clip_ymin,clip_ymax,
+    clip_zmin,clip_zmax
+};
+static inline void updateTmp(GLContext *c,
+                             GLVertex *q,GLVertex *p0,GLVertex *p1,float t)
+{
+  if (c->current_shade_model == GL_SMOOTH) {
+    q->color.v[0]=p0->color.v[0] + (p1->color.v[0]-p0->color.v[0])*t;
+    q->color.v[1]=p0->color.v[1] + (p1->color.v[1]-p0->color.v[1])*t;
+    q->color.v[2]=p0->color.v[2] + (p1->color.v[2]-p0->color.v[2])*t;
+  } else {
+    q->color.v[0]=p0->color.v[0];
+    q->color.v[1]=p0->color.v[1];
+    q->color.v[2]=p0->color.v[2];
+  }
+  if (c->texture_2d_enabled) {
+    q->tex_coord.X=p0->tex_coord.X + (p1->tex_coord.X-p0->tex_coord.X)*t;
+    q->tex_coord.Y=p0->tex_coord.Y + (p1->tex_coord.Y-p0->tex_coord.Y)*t;
+  }
+  q->clip_code=gl_clipcode(q->pc.X,q->pc.Y,q->pc.Z,q->pc.W);
+  if (q->clip_code==0){
+    gl_transform_to_viewport(c,q);
+    RGBFtoRGBI(q->color.v[0],q->color.v[1],q->color.v[2],q->zp.r,q->zp.g,q->zp.b);
+  }
+}
+static void gl_draw_triangle_clip(GLContext *c,
+                                  GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit);
+void gl_draw_triangle(GLContext *c,
+                      GLVertex *p0,GLVertex *p1,GLVertex *p2)
+{
+  int co,c_and,cc[3],front;
+  float norm;
+  cc[0]=p0->clip_code;
+  cc[1]=p1->clip_code;
+  cc[2]=p2->clip_code;
+  co=cc[0] | cc[1] | cc[2];
+  /* we handle the non clipped case here to go faster */
+  if (co==0) {
+      norm=(float)(p1->zp.x-p0->zp.x)*(float)(p2->zp.y-p0->zp.y)-
+        (float)(p2->zp.x-p0->zp.x)*(float)(p1->zp.y-p0->zp.y);
+      if (norm == 0) return;
+      front = norm < 0.0;
+      front = front ^ c->current_front_face;
+      /* back face culling */
+      if (c->cull_face_enabled) {
+        /* most used case first */
+        if (c->current_cull_face == GL_BACK) {
+          if (front == 0) return;
+          c->draw_triangle_front(c,p0,p1,p2);
+        } else if (c->current_cull_face == GL_FRONT) {
+          if (front != 0) return;
+          c->draw_triangle_back(c,p0,p1,p2);
+        } else {
+          return;
+        }
+      } else {
+        /* no culling */
+        if (front) {
+          c->draw_triangle_front(c,p0,p1,p2);
+        } else {
+          c->draw_triangle_back(c,p0,p1,p2);
+        }
+      }
+  } else {
+    c_and=cc[0] & cc[1] & cc[2];
+    if (c_and==0) {
+      gl_draw_triangle_clip(c,p0,p1,p2,0);
+    }
+  }
+}
+static void gl_draw_triangle_clip(GLContext *c,
+                                  GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit)
+{
+  int co,c_and,co1,cc[3],edge_flag_tmp,clip_mask;
+  GLVertex tmp1,tmp2,*q[3];
+  float tt;
+  cc[0]=p0->clip_code;
+  cc[1]=p1->clip_code;
+  cc[2]=p2->clip_code;
+  co=cc[0] | cc[1] | cc[2];
+  if (co == 0) {
+    gl_draw_triangle(c,p0,p1,p2);
+  } else {
+    c_and=cc[0] & cc[1] & cc[2];
+    /* the triangle is completely outside */
+    if (c_and!=0) return;
+    /* find the next direction to clip */
+    while (clip_bit < 6 && (co & (1 << clip_bit)) == 0)  {
+      clip_bit++;
+    }
+    /* this test can be true only in case of rounding errors */
+    if (clip_bit == 6) {
+#if 0
+      printf("Error:\n");
+      printf("%f %f %f %f\n",p0->pc.X,p0->pc.Y,p0->pc.Z,p0->pc.W);
+      printf("%f %f %f %f\n",p1->pc.X,p1->pc.Y,p1->pc.Z,p1->pc.W);
+      printf("%f %f %f %f\n",p2->pc.X,p2->pc.Y,p2->pc.Z,p2->pc.W);
+#endif
+      return;
+    }
+    clip_mask = 1 << clip_bit;
+    co1=(cc[0] ^ cc[1] ^ cc[2]) & clip_mask;
+    if (co1)  {
+      /* one point outside */
+      if (cc[0] & clip_mask) { q[0]=p0; q[1]=p1; q[2]=p2; }
+      else if (cc[1] & clip_mask) { q[0]=p1; q[1]=p2; q[2]=p0; }
+      else { q[0]=p2; q[1]=p0; q[2]=p1; }
+      tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc);
+      updateTmp(c,&tmp1,q[0],q[1],tt);
+      tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc);
+      updateTmp(c,&tmp2,q[0],q[2],tt);
+      tmp1.edge_flag=q[0]->edge_flag;
+      edge_flag_tmp=q[2]->edge_flag;
+      q[2]->edge_flag=0;
+      gl_draw_triangle_clip(c,&tmp1,q[1],q[2],clip_bit+1);
+      tmp2.edge_flag=0;
+      tmp1.edge_flag=0;
+      q[2]->edge_flag=edge_flag_tmp;
+      gl_draw_triangle_clip(c,&tmp2,&tmp1,q[2],clip_bit+1);
+    } else {
+      /* two points outside */
+      if ((cc[0] & clip_mask)==0) { q[0]=p0; q[1]=p1; q[2]=p2; }
+      else if ((cc[1] & clip_mask)==0) { q[0]=p1; q[1]=p2; q[2]=p0; }
+      else { q[0]=p2; q[1]=p0; q[2]=p1; }
+      tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc);
+      updateTmp(c,&tmp1,q[0],q[1],tt);
+      tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc);
+      updateTmp(c,&tmp2,q[0],q[2],tt);
+      tmp1.edge_flag=1;
+      tmp2.edge_flag=q[2]->edge_flag;
+      gl_draw_triangle_clip(c,q[0],&tmp1,&tmp2,clip_bit+1);
+    }
+  }
+}
+void gl_draw_triangle_select(GLContext *c,
+                             GLVertex *p0,GLVertex *p1,GLVertex *p2)
+{
+  gl_add_select1(c,p0->zp.z,p1->zp.z,p2->zp.z);
+}
+#ifdef PROFILE
+int count_triangles,count_triangles_textured,count_pixels;
+#endif
+void gl_draw_triangle_fill(GLContext *c,
+                           GLVertex *p0,GLVertex *p1,GLVertex *p2)
+{
+#ifdef PROFILE
+  {
+    int norm;
+    assert(p0->zp.x >= 0 && p0->zp.x < c->zb->xsize);
+    assert(p0->zp.y >= 0 && p0->zp.y < c->zb->ysize);
+    assert(p1->zp.x >= 0 && p1->zp.x < c->zb->xsize);
+    assert(p1->zp.y >= 0 && p1->zp.y < c->zb->ysize);
+    assert(p2->zp.x >= 0 && p2->zp.x < c->zb->xsize);
+    assert(p2->zp.y >= 0 && p2->zp.y < c->zb->ysize);
+    norm=(p1->zp.x-p0->zp.x)*(p2->zp.y-p0->zp.y)-
+      (p2->zp.x-p0->zp.x)*(p1->zp.y-p0->zp.y);
+    count_pixels+=abs(norm)/2;
+    count_triangles++;
+  }
+#endif
+  if (c->texture_2d_enabled) {
+#ifdef PROFILE
+    count_triangles_textured++;
+#endif
+    ZB_setTexture(c->zb,c->current_texture->images[0].pixmap);
+    ZB_fillTriangleMappingPerspective(c->zb,&p0->zp,&p1->zp,&p2->zp);
+  } else if (c->current_shade_model == GL_SMOOTH) {
+    ZB_fillTriangleSmooth(c->zb,&p0->zp,&p1->zp,&p2->zp);
+  } else {
+    ZB_fillTriangleFlat(c->zb,&p0->zp,&p1->zp,&p2->zp);
+  }
+}
+/* Render a clipped triangle in line mode */
+void gl_draw_triangle_line(GLContext *c,
+                           GLVertex *p0,GLVertex *p1,GLVertex *p2)
+{
+    if (c->depth_test) {
+        if (p0->edge_flag) ZB_line_z(c->zb,&p0->zp,&p1->zp);
+        if (p1->edge_flag) ZB_line_z(c->zb,&p1->zp,&p2->zp);
+        if (p2->edge_flag) ZB_line_z(c->zb,&p2->zp,&p0->zp);
+    } else {
+        if (p0->edge_flag) ZB_line(c->zb,&p0->zp,&p1->zp);
+        if (p1->edge_flag) ZB_line(c->zb,&p1->zp,&p2->zp);
+        if (p2->edge_flag) ZB_line(c->zb,&p2->zp,&p0->zp);
+    }
+}
+/* Render a clipped triangle in point mode */
+void gl_draw_triangle_point(GLContext *c,
+                            GLVertex *p0,GLVertex *p1,GLVertex *p2)
+{
+  if (p0->edge_flag) ZB_plot(c->zb,&p0->zp);
+  if (p1->edge_flag) ZB_plot(c->zb,&p1->zp);
+  if (p2->edge_flag) ZB_plot(c->zb,&p2->zp);
+}

 /programs/develop/libraries/TinyGL/src/error.c
 ,0 → 1,16
+#include <stdarg.h>
+#include "zgl.h"
+void gl_fatal_error(char *format, ...)
+{
+  va_list ap;
+  va_start(ap,format);
+  fprintf(stderr,"TinyGL: fatal error: ");
+  vfprintf(stderr,format,ap);
+  fprintf(stderr,"\n");
+  exit(1);
+  va_end(ap);
+}

 /programs/develop/libraries/TinyGL/src/get.c
 ,0 → 1,72
+#include "zgl.h"
+void glGetIntegerv(int pname,int *params)
+{
+  GLContext *c=gl_get_context();
+  switch(pname) {
+  case GL_VIEWPORT:
+    params[0]=c->viewport.xmin;
+    params[1]=c->viewport.ymin;
+    params[2]=c->viewport.xsize;
+    params[3]=c->viewport.ysize;
+    break;
+  case GL_MAX_MODELVIEW_STACK_DEPTH:
+    *params = MAX_MODELVIEW_STACK_DEPTH;
+    break;
+  case GL_MAX_PROJECTION_STACK_DEPTH:
+    *params = MAX_PROJECTION_STACK_DEPTH;
+    break;
+  case GL_MAX_LIGHTS:
+    *params = MAX_LIGHTS;
+    break;
+  case GL_MAX_TEXTURE_SIZE:
+    *params = 256; /* not completely true, but... */
+    break;
+  case GL_MAX_TEXTURE_STACK_DEPTH:
+    *params = MAX_TEXTURE_STACK_DEPTH;
+    break;
+  default:
+    gl_fatal_error("glGet: option not implemented");
+    break;
+  }
+}
+void glGetFloatv(int pname, float *v)
+{
+  int i;
+  int mnr = 0; /* just a trick to return the correct matrix */
+  GLContext *c = gl_get_context();
+  switch (pname) {
+  case GL_TEXTURE_MATRIX:
+    mnr++;
+  case GL_PROJECTION_MATRIX:
+    mnr++;
+  case GL_MODELVIEW_MATRIX:
+    {
+      float *p = &c->matrix_stack_ptr[mnr]->m[0][0];;
+      for (i = 0; i < 4; i++) {
+        *v++ = p[0];
+        *v++ = p[4];
+        *v++ = p[8];
+        *v++ = p[12];
+        p++;
+      }
+    }
+    break;
+  case GL_LINE_WIDTH:
+    *v = 1.0f;
+    break;
+  case GL_LINE_WIDTH_RANGE:
+    v[0] = v[1] = 1.0f;
+    break;
+  case GL_POINT_SIZE:
+    *v = 1.0f;
+    break;
+  case GL_POINT_SIZE_RANGE:
+    v[0] = v[1] = 1.0f;
+  default:
+    fprintf(stderr,"warning: unknown pname in glGetFloatv()\n");
+    break;
+  }
+}

 /programs/develop/libraries/TinyGL/src/glu.c
 ,0 → 1,343
+#include <stdlib.h>
+#include <math.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+void drawTorus(float rc, int numc, float rt, int numt)
+{
+    int i, j, k;
+    double s, t;
+    double x, y, z;
+    double pi, twopi;
+    pi = 3.14159265358979323846;
+    twopi = 2 * pi;
+    for (i = 0; i < numc; i++) {
+        glBegin(GL_QUAD_STRIP);
+        for (j = 0; j <= numt; j++) {
+            for (k = 1; k >= 0; k--) {
+                s = (i + k) % numc + 0.5;
+                t = j % numt;
+                x = cos(t*twopi/numt) * cos(s*twopi/numc);
+                y = sin(t*twopi/numt) * cos(s*twopi/numc);
+                z = sin(s*twopi/numc);
+                glNormal3f(x, y, z);
+                x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt);
+                y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt);
+                z = rc * sin(s*twopi/numc);
+                glVertex3f(x, y, z);
+            }
+        }
+        glEnd();
+    }
+}
+static void normal3f( GLfloat x, GLfloat y, GLfloat z )
+{
+   GLdouble mag;
+   mag = sqrt( x*x + y*y + z*z );
+   if (mag>0.00001F) {
+      x /= mag;
+      y /= mag;
+      z /= mag;
+   }
+   glNormal3f( x, y, z );
+}
+void gluPerspective( GLdouble fovy, GLdouble aspect,
+                     GLdouble zNear, GLdouble zFar )
+{
+   GLdouble xmin, xmax, ymin, ymax;
+   ymax = zNear * tan( fovy * M_PI / 360.0 );
+   ymin = -ymax;
+   xmin = ymin * aspect;
+   xmax = ymax * aspect;
+   glFrustum( xmin, xmax, ymin, ymax, zNear, zFar );
+}
+void
+gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez,
+          GLdouble centerx, GLdouble centery, GLdouble centerz,
+          GLdouble upx, GLdouble upy, GLdouble upz)
+{
+   GLfloat m[16];
+   GLdouble x[3], y[3], z[3];
+   GLdouble mag;
+   /* Make rotation matrix */
+   /* Z vector */
+   z[0] = eyex - centerx;
+   z[1] = eyey - centery;
+   z[2] = eyez - centerz;
+   mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
+   if (mag) {                   /* mpichler, 19950515 */
+      z[0] /= mag;
+      z[1] /= mag;
+      z[2] /= mag;
+   }
+   /* Y vector */
+   y[0] = upx;
+   y[1] = upy;
+   y[2] = upz;
+   /* X vector = Y cross Z */
+   x[0] = y[1] * z[2] - y[2] * z[1];
+   x[1] = -y[0] * z[2] + y[2] * z[0];
+   x[2] = y[0] * z[1] - y[1] * z[0];
+   /* Recompute Y = Z cross X */
+   y[0] = z[1] * x[2] - z[2] * x[1];
+   y[1] = -z[0] * x[2] + z[2] * x[0];
+   y[2] = z[0] * x[1] - z[1] * x[0];
+   /* mpichler, 19950515 */
+   /* cross product gives area of parallelogram, which is < 1.0 for
+    * non-perpendicular unit-length vectors; so normalize x, y here
+    */
+   mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
+   if (mag) {
+      x[0] /= mag;
+      x[1] /= mag;
+      x[2] /= mag;
+   }
+   mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
+   if (mag) {
+      y[0] /= mag;
+      y[1] /= mag;
+      y[2] /= mag;
+   }
+#define M(row,col)  m[col*4+row]
+   M(0, 0) = x[0];
+   M(0, 1) = x[1];
+   M(0, 2) = x[2];
+   M(0, 3) = 0.0;
+   M(1, 0) = y[0];
+   M(1, 1) = y[1];
+   M(1, 2) = y[2];
+   M(1, 3) = 0.0;
+   M(2, 0) = z[0];
+   M(2, 1) = z[1];
+   M(2, 2) = z[2];
+   M(2, 3) = 0.0;
+   M(3, 0) = 0.0;
+   M(3, 1) = 0.0;
+   M(3, 2) = 0.0;
+   M(3, 3) = 1.0;
+#undef M
+   glMultMatrixf(m);
+   /* Translate Eye to Origin */
+   glTranslatef(-eyex, -eyey, -eyez);
+}
+GLUquadricObj *gluNewQuadric(void)
+{
+  return NULL;
+}
+void gluQuadricDrawStyle(GLUquadricObj *obj, int style)
+{
+}
+void gluCylinder( GLUquadricObj *qobj,
+                  GLdouble baseRadius, GLdouble topRadius, GLdouble height,
+                  GLint slices, GLint stacks )
+{
+   GLdouble da, r, dr, dz;
+   GLfloat z, nz, nsign;
+   GLint i, j;
+   GLfloat du = 1.0 / slices;
+   GLfloat dv = 1.0 / stacks;
+   GLfloat tcx = 0.0, tcy = 0.0;
+   nsign = 1.0;
+   da = 2.0*M_PI / slices;
+   dr = (topRadius-baseRadius) / stacks;
+   dz = height / stacks;
+   nz = (baseRadius-topRadius) / height;  /* Z component of normal vectors */
+   for (i=0;i<slices;i++) {
+         GLfloat x1 = -sin(i*da);
+         GLfloat y1 = cos(i*da);
+         GLfloat x2 = -sin((i+1)*da);
+         GLfloat y2 = cos((i+1)*da);
+         z = 0.0;
+         r = baseRadius;
+         tcy = 0.0;
+         glBegin( GL_QUAD_STRIP );
+         for (j=0;j<=stacks;j++) {
+            if (nsign==1.0) {
+               normal3f( x1*nsign, y1*nsign, nz*nsign );
+               glTexCoord2f(tcx, tcy);
+               glVertex3f( x1*r, y1*r, z );
+               normal3f( x2*nsign, y2*nsign, nz*nsign );
+               glTexCoord2f(tcx+du, tcy);
+               glVertex3f( x2*r, y2*r, z );
+            }
+            else {
+               normal3f( x2*nsign, y2*nsign, nz*nsign );
+               glTexCoord2f(tcx, tcy);
+               glVertex3f( x2*r, y2*r, z );
+               normal3f( x1*nsign, y1*nsign, nz*nsign );
+               glTexCoord2f(tcx+du, tcy);
+               glVertex3f( x1*r, y1*r, z );
+            }
+            z += dz;
+            r += dr;
+            tcy += dv;
+         }
+         glEnd();
+         tcx += du;
+      }
+}
+/* Disk (adapted from Mesa) */
+void gluDisk( GLUquadricObj *qobj,
+              GLdouble innerRadius, GLdouble outerRadius,
+              GLint slices, GLint loops )
+{
+   GLdouble a, da;
+   GLfloat dr;
+   GLfloat r1, r2, dtc;
+   GLint s, l;
+   GLfloat sa,ca;
+   /* Normal vectors */
+         glNormal3f( 0.0, 0.0, +1.0 );
+   da = 2.0*M_PI / slices;
+   dr = (outerRadius-innerRadius) / (GLfloat) loops;
+   /* texture of a gluDisk is a cut out of the texture unit square */
+   /* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */
+   dtc = 2.0f * outerRadius;
+   r1 = innerRadius;
+   for (l=0;l<loops;l++) {
+            r2 = r1 + dr;
+               glBegin( GL_QUAD_STRIP );
+               for (s=0;s<=slices;s++) {
+                  if (s==slices) a = 0.0;
+                  else  a = s * da;
+                  sa = sin(a); ca = cos(a);
+                  glTexCoord2f(0.5+sa*r2/dtc,0.5+ca*r2/dtc);
+                  glVertex2f( r2*sa, r2*ca );
+                  glTexCoord2f(0.5+sa*r1/dtc,0.5+ca*r1/dtc);
+                  glVertex2f( r1*sa, r1*ca );
+               }
+               glEnd();
+            r1 = r2;
+         }
+}
+/*
+ * Sphere (adapted from Mesa)
+ */
+void gluSphere(GLUquadricObj *qobj,
+               float radius,int slices,int stacks)
+{
+   float rho, drho, theta, dtheta;
+   float x, y, z;
+   float s, t, ds, dt;
+   int i, j, imin, imax;
+   int normals;
+   float nsign;
+   normals=1;
+   nsign=1;
+   drho = M_PI / (float) stacks;
+   dtheta = 2.0 * M_PI / (float) slices;
+  /* draw +Z end as a triangle fan */
+  glBegin( GL_TRIANGLE_FAN );
+  glNormal3f( 0.0, 0.0, 1.0 );
+  glTexCoord2f(0.5,0.0);
+  glVertex3f( 0.0, 0.0, nsign * radius );
+  for (j=0;j<=slices;j++) {
+         theta = (j==slices) ? 0.0 : j * dtheta;
+         x = -sin(theta) * sin(drho);
+         y = cos(theta) * sin(drho);
+         z = nsign * cos(drho);
+         if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+         glVertex3f( x*radius, y*radius, z*radius );
+      }
+   glEnd();
+      ds = 1.0 / slices;
+      dt = 1.0 / stacks;
+      t = 1.0;  /* because loop now runs from 0 */
+      if (1) {
+        imin = 0;
+        imax = stacks;
+      }
+      else {
+        imin = 1;
+        imax = stacks-1;
+      }
+      /* draw intermediate stacks as quad strips */
+      for (i=imin;i<imax;i++) {
+         rho = i * drho;
+         glBegin( GL_QUAD_STRIP );
+         s = 0.0;
+         for (j=0;j<=slices;j++) {
+            theta = (j==slices) ? 0.0 : j * dtheta;
+            x = -sin(theta) * sin(rho);
+            y = cos(theta) * sin(rho);
+            z = nsign * cos(rho);
+            if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+            glTexCoord2f(s,1-t);
+            glVertex3f( x*radius, y*radius, z*radius );
+            x = -sin(theta) * sin(rho+drho);
+            y = cos(theta) * sin(rho+drho);
+            z = nsign * cos(rho+drho);
+            if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+            glTexCoord2f(s,1-(t-dt));
+            s += ds;
+            glVertex3f( x*radius, y*radius, z*radius );
+         }
+         glEnd();
+         t -= dt;
+      }
+/* draw -Z end as a triangle fan */
+    glBegin( GL_TRIANGLE_FAN );
+    glNormal3f( 0.0, 0.0, -1.0 );
+      glTexCoord2f(0.5,1.0);
+      glVertex3f( 0.0, 0.0, -radius*nsign );
+      rho = M_PI - drho;
+      s = 1.0;
+      t = dt;
+      for (j=slices;j>=0;j--) {
+         theta = (j==slices) ? 0.0 : j * dtheta;
+         x = -sin(theta) * sin(rho);
+         y = cos(theta) * sin(rho);
+         z = nsign * cos(rho);
+         if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+         glTexCoord2f(s,1-t);
+         s -= ds;
+         glVertex3f( x*radius, y*radius, z*radius );
+      }
+      glEnd();
+}

 /programs/develop/libraries/TinyGL/src/image_util.c
 ,0 → 1,136
+#include "zgl.h"
+/*
+ * image conversion
+ */
+void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb,
+                             int xsize,int ysize)
+{
+  int i,n;
+  unsigned char *p;
+  p=rgb;
+  n=xsize*ysize;
+  for(i=0;i<n;i++) {
+    pixmap[i]=((p[0]&0xF8)<<8) | ((p[1]&0xFC)<<3) | ((p[2]&0xF8)>>3);
+    p+=3;
+  }
+}
+void gl_convertRGB_to_8A8R8G8B(unsigned int *pixmap, unsigned char *rgb,
+                               int xsize, int ysize)
+{
+    int i,n;
+    unsigned char *p;
+    p=rgb;
+    n=xsize*ysize;
+    for(i=0;i<n;i++) {
+        pixmap[i]=(((unsigned int)p[0])<<16) |
+            (((unsigned int)p[1])<<8) |
+            (((unsigned int)p[2]));
+        p+=3;
+    }
+}
+/*
+ * linear interpolation with xf,yf normalized to 2^16
+ */
+#define INTERP_NORM_BITS  16
+#define INTERP_NORM       (1 << INTERP_NORM_BITS)
+static inline int interpolate(int v00,int v01,int v10,int xf,int yf)
+{
+  return v00+(((v01-v00)*xf + (v10-v00)*yf) >> INTERP_NORM_BITS);
+}
+/*
+ * TODO: more accurate resampling
+ */
+void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest,
+                    unsigned char *src,int xsize_src,int ysize_src)
+{
+  unsigned char *pix,*pix_src;
+  float x1,y1,x1inc,y1inc;
+  int xi,yi,j,xf,yf,x,y;
+  pix=dest;
+  pix_src=src;
+  x1inc=(float) (xsize_src - 1) / (float) (xsize_dest - 1);
+  y1inc=(float) (ysize_src - 1) / (float) (ysize_dest - 1);
+  y1=0;
+  for(y=0;y<ysize_dest;y++) {
+    x1=0;
+    for(x=0;x<xsize_dest;x++) {
+      xi=(int) x1;
+      yi=(int) y1;
+      xf=(int) ((x1 - floor(x1)) * INTERP_NORM);
+      yf=(int) ((y1 - floor(y1)) * INTERP_NORM);
+      if ((xf+yf) <= INTERP_NORM) {
+        for(j=0;j<3;j++) {
+          pix[j]=interpolate(pix_src[(yi*xsize_src+xi)*3+j],
+                             pix_src[(yi*xsize_src+xi+1)*3+j],
+                             pix_src[((yi+1)*xsize_src+xi)*3+j],
+                             xf,yf);
+        }
+      } else {
+        xf=INTERP_NORM - xf;
+        yf=INTERP_NORM - yf;
+        for(j=0;j<3;j++) {
+          pix[j]=interpolate(pix_src[((yi+1)*xsize_src+xi+1)*3+j],
+                             pix_src[((yi+1)*xsize_src+xi)*3+j],
+                             pix_src[(yi*xsize_src+xi+1)*3+j],
+                             xf,yf);
+        }
+      }
+      pix+=3;
+      x1+=x1inc;
+    }
+    y1+=y1inc;
+  }
+}
+#define FRAC_BITS 16
+/* resizing with no interlating nor nearest pixel */
+void gl_resizeImageNoInterpolate(unsigned char *dest,int xsize_dest,int ysize_dest,
+                                 unsigned char *src,int xsize_src,int ysize_src)
+{
+  unsigned char *pix,*pix_src,*pix1;
+  int x1,y1,x1inc,y1inc;
+  int xi,yi,x,y;
+  pix=dest;
+  pix_src=src;
+  x1inc=(int)((float) ((xsize_src)<<FRAC_BITS) / (float) (xsize_dest));
+  y1inc=(int)((float) ((ysize_src)<<FRAC_BITS) / (float) (ysize_dest));
+  y1=0;
+  for(y=0;y<ysize_dest;y++) {
+    x1=0;
+    for(x=0;x<xsize_dest;x++) {
+      xi=x1 >> FRAC_BITS;
+      yi=y1 >> FRAC_BITS;
+      pix1=pix_src+(yi*xsize_src+xi)*3;
+      pix[0]=pix1[0];
+      pix[1]=pix1[1];
+      pix[2]=pix1[2];
+      pix+=3;
+      x1+=x1inc;
+    }
+    y1+=y1inc;
+  }
+}

 /programs/develop/libraries/TinyGL/src/init.c
 ,0 → 1,189
+#include "zgl.h"
+GLContext *gl_ctx;
+void initSharedState(GLContext *c)
+{
+  GLSharedState *s=&c->shared_state;
+  s->lists=gl_zalloc(sizeof(GLList *) * MAX_DISPLAY_LISTS);
+  s->texture_hash_table=
+      gl_zalloc(sizeof(GLTexture *) * TEXTURE_HASH_TABLE_SIZE);
+  alloc_texture(c,0);
+}
+void endSharedState(GLContext *c)
+{
+  GLSharedState *s=&c->shared_state;
+  int i;
+  for(i=0;i<MAX_DISPLAY_LISTS;i++) {
+    /* TODO */
+  }
+  gl_free(s->lists);
+  gl_free(s->texture_hash_table);
+}
+void glInit(void *zbuffer1)
+{
+  ZBuffer *zbuffer=(ZBuffer *)zbuffer1;
+  GLContext *c;
+  GLViewport *v;
+  int i;
+  c=gl_zalloc(sizeof(GLContext));
+  gl_ctx=c;
+  c->zb=zbuffer;
+  /* allocate GLVertex array */
+  c->vertex_max = POLYGON_MAX_VERTEX;
+  c->vertex = gl_malloc(POLYGON_MAX_VERTEX*sizeof(GLVertex));
+  /* viewport */
+  v=&c->viewport;
+  v->xmin=0;
+  v->ymin=0;
+  v->xsize=zbuffer->xsize;
+  v->ysize=zbuffer->ysize;
+  v->updated=1;
+  /* shared state */
+  initSharedState(c);
+  /* lists */
+  c->exec_flag=1;
+  c->compile_flag=0;
+  c->print_flag=0;
+  c->in_begin=0;
+  /* lights */
+  for(i=0;i<MAX_LIGHTS;i++) {
+    GLLight *l=&c->lights[i];
+    l->ambient=gl_V4_New(0,0,0,1);
+    l->diffuse=gl_V4_New(1,1,1,1);
+    l->specular=gl_V4_New(1,1,1,1);
+    l->position=gl_V4_New(0,0,1,0);
+    l->norm_position=gl_V3_New(0,0,1);
+    l->spot_direction=gl_V3_New(0,0,-1);
+    l->norm_spot_direction=gl_V3_New(0,0,-1);
+    l->spot_exponent=0;
+    l->spot_cutoff=180;
+    l->attenuation[0]=1;
+    l->attenuation[1]=0;
+    l->attenuation[2]=0;
+    l->enabled=0;
+  }
+  c->first_light=NULL;
+  c->ambient_light_model=gl_V4_New(0.2,0.2,0.2,1);
+  c->local_light_model=0;
+  c->lighting_enabled=0;
+  c->light_model_two_side = 0;
+  /* default materials */
+  for(i=0;i<2;i++) {
+    GLMaterial *m=&c->materials[i];
+    m->emission=gl_V4_New(0,0,0,1);
+    m->ambient=gl_V4_New(0.2,0.2,0.2,1);
+    m->diffuse=gl_V4_New(0.8,0.8,0.8,1);
+    m->specular=gl_V4_New(0,0,0,1);
+    m->shininess=0;
+  }
+  c->current_color_material_mode=GL_FRONT_AND_BACK;
+  c->current_color_material_type=GL_AMBIENT_AND_DIFFUSE;
+  c->color_material_enabled=0;
+  /* textures */
+  glInitTextures(c);
+  /* default state */
+  c->current_color.X=1.0;
+  c->current_color.Y=1.0;
+  c->current_color.Z=1.0;
+  c->current_color.W=1.0;
+  c->longcurrent_color[0] = 65535;
+  c->longcurrent_color[1] = 65535;
+  c->longcurrent_color[2] = 65535;
+  c->current_normal.X=1.0;
+  c->current_normal.Y=0.0;
+  c->current_normal.Z=0.0;
+  c->current_normal.W=0.0;
+  c->current_edge_flag=1;
+  c->current_tex_coord.X=0;
+  c->current_tex_coord.Y=0;
+  c->current_tex_coord.Z=0;
+  c->current_tex_coord.W=1;
+  c->polygon_mode_front=GL_FILL;
+  c->polygon_mode_back=GL_FILL;
+  c->current_front_face=0; /* 0 = GL_CCW  1 = GL_CW */
+  c->current_cull_face=GL_BACK;
+  c->current_shade_model=GL_SMOOTH;
+  c->cull_face_enabled=0;
+  /* clear */
+  c->clear_color.v[0]=0;
+  c->clear_color.v[1]=0;
+  c->clear_color.v[2]=0;
+  c->clear_color.v[3]=0;
+  c->clear_depth=0;
+  /* selection */
+  c->render_mode=GL_RENDER;
+  c->select_buffer=NULL;
+  c->name_stack_size=0;
+  /* matrix */
+  c->matrix_mode=0;
+  c->matrix_stack_depth_max[0]=MAX_MODELVIEW_STACK_DEPTH;
+  c->matrix_stack_depth_max[1]=MAX_PROJECTION_STACK_DEPTH;
+  c->matrix_stack_depth_max[2]=MAX_TEXTURE_STACK_DEPTH;
+  for(i=0;i<3;i++) {
+    c->matrix_stack[i]=gl_zalloc(c->matrix_stack_depth_max[i] * sizeof(M4));
+    c->matrix_stack_ptr[i]=c->matrix_stack[i];
+  }
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glMatrixMode(GL_TEXTURE);
+  glLoadIdentity();
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+  c->matrix_model_projection_updated=1;
+  /* opengl 1.1 arrays */
+  c->client_states = 0;
+  /* opengl 1.1 polygon offset */
+  c->offset_states = 0;
+  /* clear the resize callback function pointer */
+  c->gl_resize_viewport = NULL;
+  /* specular buffer */
+  c->specbuf_first = NULL;
+  c->specbuf_used_counter = 0;
+  c->specbuf_num_buffers = 0;
+  /* depth test */
+  c->depth_test = 0;
+}
+void glClose(void)
+{
+  GLContext *c=gl_get_context();
+  endSharedState(c);
+  gl_free(c);
+}

 /programs/develop/libraries/TinyGL/src/kosgl.c
 ,0 → 1,127
+/* simple gl like driver for TinyGL and KolibriOS - porting iadn */
+#include <GL/gl.h>
+#include "kosgl.h"
+#include "zgl.h"
+typedef struct {
+    GLContext *gl_context;
+    int xsize,ysize;
+    int dx,dy;
+    int x,y;
+} TinyGLContext;
+KOSGLContext kosglCreateContext(KOSGLContext shareList, int flags)
+{
+  TinyGLContext *ctx;
+  if (shareList != NULL) {
+    gl_fatal_error("No sharing available in TinyGL");
+  }
+    ctx=gl_malloc(sizeof(TinyGLContext));
+  if (!ctx)
+      return NULL;
+  ctx->gl_context=NULL;
+  return (KOSGLContext) ctx;
+}
+void kosglDestroyContext( KOSGLContext ctx1 )
+{
+  TinyGLContext *ctx = (TinyGLContext *) ctx1;
+  if (ctx->gl_context != NULL) {
+    glClose();
+  }
+  gl_free(ctx);
+}
+/* resize the glx viewport : we try to use the xsize and ysize
+   given. We return the effective size which is guaranted to be smaller */
+static int gl_resize_viewport(GLContext *c,int *xsize_ptr,int *ysize_ptr)
+{
+  TinyGLContext *ctx;
+  int xsize,ysize;
+  ctx=(TinyGLContext *)c->opaque;
+  xsize=*xsize_ptr;
+  ysize=*ysize_ptr;
+  /* we ensure that xsize and ysize are multiples of 2 for the zbuffer.
+     TODO: find a better solution */
+  xsize&=~3;
+  ysize&=~3;
+  if (xsize == 0 || ysize == 0) return -1;
+  *xsize_ptr=xsize-1;
+  *ysize_ptr=ysize-1;
+  ctx->dx = xsize;
+  ctx->dy = ysize;
+  ctx->xsize=xsize;
+  ctx->ysize=ysize;
+  /* resize the Z buffer */
+  ZB_resize(c->zb,NULL,xsize,ysize);
+  return 0;
+}
+/* we assume here that drawable is a window */
+int kosglMakeCurrent( int win_x0, int win_y0,int win_x, int win_y, KOSGLContext ctx1)
+{
+  TinyGLContext *ctx = (TinyGLContext *) ctx1;
+  int mode;
+  ZBuffer *zb;
+  if (ctx->gl_context == NULL) {
+      /* create the TinyGL context */
+      ctx->x = win_x0;
+          ctx->y = win_y0;
+          ctx->dx = win_x;
+          ctx->dy = win_y;
+      /* currently, we only support 16 bit rendering */
+      mode = ZB_MODE_RGB24;
+      zb=ZB_open(win_x,win_y,mode,0,NULL,NULL,NULL);
+      if (zb == NULL) {
+          fprintf(stderr, "Error while initializing Z buffer\n");
+          exit(1);
+      }
+      /* initialisation of the TinyGL interpreter */
+      glInit(zb);
+      ctx->gl_context=gl_get_context();
+      ctx->gl_context->opaque=(void *) ctx;
+      ctx->gl_context->gl_resize_viewport=gl_resize_viewport;
+      /* set the viewport : we force a call to gl_resize_viewport */
+      ctx->gl_context->viewport.xsize=-1;
+      ctx->gl_context->viewport.ysize=-1;
+      glViewport(0, 0, win_x, win_y);
+  }
+  return 1;
+}
+void kosglSwapBuffers( )
+{
+    GLContext *gl_context;
+    TinyGLContext *ctx;
+    /* retrieve the current TinyGLContext */
+    gl_context=gl_get_context();
+    ctx=(TinyGLContext *)gl_context->opaque;
+        __asm__ __volatile__("int $0x40"::"a"(7),
+                                      "b"((char *)gl_context->zb->pbuf),
+                                                                      "c"((ctx->dx<<16)|ctx->dy),
+                                                                          "d"((ctx->x<<16)|ctx->y));
+}

 /programs/develop/libraries/TinyGL/src/light.c
 ,0 → 1,306
+#include "zgl.h"
+#include "msghandling.h"
+void glopMaterial(GLContext *c,GLParam *p)
+{
+  int mode=p[1].i;
+  int type=p[2].i;
+  float *v=&p[3].f;
+  int i;
+  GLMaterial *m;
+  if (mode == GL_FRONT_AND_BACK) {
+    p[1].i=GL_FRONT;
+    glopMaterial(c,p);
+    mode=GL_BACK;
+  }
+  if (mode == GL_FRONT) m=&c->materials[0];
+  else m=&c->materials[1];
+  switch(type) {
+  case GL_EMISSION:
+    for(i=0;i<4;i++)
+      m->emission.v[i]=v[i];
+    break;
+  case GL_AMBIENT:
+    for(i=0;i<4;i++)
+      m->ambient.v[i]=v[i];
+    break;
+  case GL_DIFFUSE:
+    for(i=0;i<4;i++)
+      m->diffuse.v[i]=v[i];
+    break;
+  case GL_SPECULAR:
+    for(i=0;i<4;i++)
+      m->specular.v[i]=v[i];
+    break;
+  case GL_SHININESS:
+    m->shininess=v[0];
+    m->shininess_i = (v[0]/128.0f)*SPECULAR_BUFFER_RESOLUTION;
+    break;
+  case GL_AMBIENT_AND_DIFFUSE:
+    for(i=0;i<4;i++)
+      m->diffuse.v[i]=v[i];
+    for(i=0;i<4;i++)
+      m->ambient.v[i]=v[i];
+    break;
+  default:
+    assert(0);
+  }
+}
+void glopColorMaterial(GLContext *c,GLParam *p)
+{
+  int mode=p[1].i;
+  int type=p[2].i;
+  c->current_color_material_mode=mode;
+  c->current_color_material_type=type;
+}
+void glopLight(GLContext *c,GLParam *p)
+{
+  int light=p[1].i;
+  int type=p[2].i;
+  V4 v;
+  GLLight *l;
+  int i;
+  assert(light >= GL_LIGHT0 && light < GL_LIGHT0+MAX_LIGHTS );
+  l=&c->lights[light-GL_LIGHT0];
+  for(i=0;i<4;i++) v.v[i]=p[3+i].f;
+  switch(type) {
+  case GL_AMBIENT:
+    l->ambient=v;
+    break;
+  case GL_DIFFUSE:
+    l->diffuse=v;
+    break;
+  case GL_SPECULAR:
+    l->specular=v;
+    break;
+  case GL_POSITION:
+    {
+      V4 pos;
+      gl_M4_MulV4(&pos,c->matrix_stack_ptr[0],&v);
+      l->position=pos;
+      if (l->position.v[3] == 0) {
+        l->norm_position.X=pos.X;
+        l->norm_position.Y=pos.Y;
+        l->norm_position.Z=pos.Z;
+        gl_V3_Norm(&l->norm_position);
+      }
+    }
+    break;
+  case GL_SPOT_DIRECTION:
+    for(i=0;i<3;i++) {
+      l->spot_direction.v[i]=v.v[i];
+      l->norm_spot_direction.v[i]=v.v[i];
+    }
+    gl_V3_Norm(&l->norm_spot_direction);
+    break;
+  case GL_SPOT_EXPONENT:
+    l->spot_exponent=v.v[0];
+    break;
+  case GL_SPOT_CUTOFF:
+    {
+      float a=v.v[0];
+      assert(a == 180 || (a>=0 && a<=90));
+      l->spot_cutoff=a;
+      if (a != 180) l->cos_spot_cutoff=cos(a * M_PI / 180.0);
+    }
+    break;
+  case GL_CONSTANT_ATTENUATION:
+    l->attenuation[0]=v.v[0];
+    break;
+  case GL_LINEAR_ATTENUATION:
+    l->attenuation[1]=v.v[0];
+    break;
+  case GL_QUADRATIC_ATTENUATION:
+    l->attenuation[2]=v.v[0];
+    break;
+  default:
+    assert(0);
+  }
+}
+void glopLightModel(GLContext *c,GLParam *p)
+{
+  int pname=p[1].i;
+  float *v=&p[2].f;
+  int i;
+  switch(pname) {
+  case GL_LIGHT_MODEL_AMBIENT:
+    for(i=0;i<4;i++)
+      c->ambient_light_model.v[i]=v[i];
+    break;
+  case GL_LIGHT_MODEL_LOCAL_VIEWER:
+    c->local_light_model=(int)v[0];
+    break;
+  case GL_LIGHT_MODEL_TWO_SIDE:
+    c->light_model_two_side = (int)v[0];
+    break;
+  default:
+    tgl_warning("glopLightModel: illegal pname: 0x%x\n", pname);
+    //assert(0);
+    break;
+  }
+}
+static inline float clampf(float a,float min,float max)
+{
+  if (a<min) return min;
+  else if (a>max) return max;
+  else return a;
+}
+void gl_enable_disable_light(GLContext *c,int light,int v)
+{
+  GLLight *l=&c->lights[light];
+  if (v && !l->enabled) {
+    l->enabled=1;
+    l->next=c->first_light;
+    c->first_light=l;
+    l->prev=NULL;
+  } else if (!v && l->enabled) {
+    l->enabled=0;
+    if (l->prev == NULL) c->first_light=l->next;
+    else l->prev->next=l->next;
+    if (l->next != NULL) l->next->prev=l->prev;
+  }
+}
+/* non optimized lightening model */
+void gl_shade_vertex(GLContext *c,GLVertex *v)
+{
+  float R,G,B,A;
+  GLMaterial *m;
+  GLLight *l;
+  V3 n,s,d;
+  float dist,tmp,att,dot,dot_spot,dot_spec;
+  int twoside = c->light_model_two_side;
+  m=&c->materials[0];
+  n.X=v->normal.X;
+  n.Y=v->normal.Y;
+  n.Z=v->normal.Z;
+  R=m->emission.v[0]+m->ambient.v[0]*c->ambient_light_model.v[0];
+  G=m->emission.v[1]+m->ambient.v[1]*c->ambient_light_model.v[1];
+  B=m->emission.v[2]+m->ambient.v[2]*c->ambient_light_model.v[2];
+  A=clampf(m->diffuse.v[3],0,1);
+  for(l=c->first_light;l!=NULL;l=l->next) {
+    float lR,lB,lG;
+    /* ambient */
+    lR=l->ambient.v[0] * m->ambient.v[0];
+    lG=l->ambient.v[1] * m->ambient.v[1];
+    lB=l->ambient.v[2] * m->ambient.v[2];
+    if (l->position.v[3] == 0) {
+      /* light at infinity */
+      d.X=l->position.v[0];
+      d.Y=l->position.v[1];
+      d.Z=l->position.v[2];
+      att=1;
+    } else {
+      /* distance attenuation */
+      d.X=l->position.v[0]-v->ec.v[0];
+      d.Y=l->position.v[1]-v->ec.v[1];
+      d.Z=l->position.v[2]-v->ec.v[2];
+      dist=sqrt(d.X*d.X+d.Y*d.Y+d.Z*d.Z);
+      if (dist>1E-3) {
+        tmp=1/dist;
+        d.X*=tmp;
+        d.Y*=tmp;
+        d.Z*=tmp;
+      }
+      att=1.0f/(l->attenuation[0]+dist*(l->attenuation[1]+
+                                     dist*l->attenuation[2]));
+    }
+    dot=d.X*n.X+d.Y*n.Y+d.Z*n.Z;
+    if (twoside && dot < 0) dot = -dot;
+    if (dot>0) {
+      /* diffuse light */
+      lR+=dot * l->diffuse.v[0] * m->diffuse.v[0];
+      lG+=dot * l->diffuse.v[1] * m->diffuse.v[1];
+      lB+=dot * l->diffuse.v[2] * m->diffuse.v[2];
+      /* spot light */
+      if (l->spot_cutoff != 180) {
+        dot_spot=-(d.X*l->norm_spot_direction.v[0]+
+                   d.Y*l->norm_spot_direction.v[1]+
+                   d.Z*l->norm_spot_direction.v[2]);
+        if (twoside && dot_spot < 0) dot_spot = -dot_spot;
+        if (dot_spot < l->cos_spot_cutoff) {
+          /* no contribution */
+          continue;
+        } else {
+          /* TODO: optimize */
+          if (l->spot_exponent > 0) {
+            att=att*pow(dot_spot,l->spot_exponent);
+          }
+        }
+      }
+      /* specular light */
+      if (c->local_light_model) {
+        V3 vcoord;
+        vcoord.X=v->ec.X;
+        vcoord.Y=v->ec.Y;
+        vcoord.Z=v->ec.Z;
+        gl_V3_Norm(&vcoord);
+        s.X=d.X-vcoord.X;
+        s.Y=d.Y-vcoord.X;
+        s.Z=d.Z-vcoord.X;
+      } else {
+        s.X=d.X;
+        s.Y=d.Y;
+        s.Z=d.Z+1.0;
+      }
+      dot_spec=n.X*s.X+n.Y*s.Y+n.Z*s.Z;
+      if (twoside && dot_spec < 0) dot_spec = -dot_spec;
+      if (dot_spec>0) {
+        GLSpecBuf *specbuf;
+        int idx;
+        tmp=sqrt(s.X*s.X+s.Y*s.Y+s.Z*s.Z);
+        if (tmp > 1E-3) {
+          dot_spec=dot_spec / tmp;
+        }
+        /* TODO: optimize */
+        /* testing specular buffer code */
+        /* dot_spec= pow(dot_spec,m->shininess);*/
+        specbuf = specbuf_get_buffer(c, m->shininess_i, m->shininess);
+        idx = (int)(dot_spec*SPECULAR_BUFFER_SIZE);
+        if (idx > SPECULAR_BUFFER_SIZE) idx = SPECULAR_BUFFER_SIZE;
+        dot_spec = specbuf->buf[idx];
+        lR+=dot_spec * l->specular.v[0] * m->specular.v[0];
+        lG+=dot_spec * l->specular.v[1] * m->specular.v[1];
+        lB+=dot_spec * l->specular.v[2] * m->specular.v[2];
+      }
+    }
+    R+=att * lR;
+    G+=att * lG;
+    B+=att * lB;
+  }
+  v->color.v[0]=clampf(R,0,1);
+  v->color.v[1]=clampf(G,0,1);
+  v->color.v[2]=clampf(B,0,1);
+  v->color.v[3]=A;
+}

 /programs/develop/libraries/TinyGL/src/list.c
 ,0 → 1,251
+#include "zgl.h"
+static char *op_table_str[]=
+{
+#define ADD_OP(a,b,c) "gl" #a " " #c,
+#include "opinfo.h"
+};
+static void (*op_table_func[])(GLContext *,GLParam *)=
+{
+#define ADD_OP(a,b,c) glop ## a ,
+#include "opinfo.h"
+};
+static int op_table_size[]=
+{
+#define ADD_OP(a,b,c) b + 1 ,
+#include "opinfo.h"
+};
+static GLList *find_list(GLContext *c,unsigned int list)
+{
+  return c->shared_state.lists[list];
+}
+static void delete_list(GLContext *c,int list)
+{
+  GLParamBuffer *pb,*pb1;
+  GLList *l;
+  l=find_list(c,list);
+  assert(l != NULL);
+  /* free param buffer */
+  pb=l->first_op_buffer;
+  while (pb!=NULL) {
+    pb1=pb->next;
+    gl_free(pb);
+    pb=pb1;
+  }
+  gl_free(l);
+  c->shared_state.lists[list]=NULL;
+}
+static GLList *alloc_list(GLContext *c,int list)
+{
+  GLList *l;
+  GLParamBuffer *ob;
+  l=gl_zalloc(sizeof(GLList));
+  ob=gl_zalloc(sizeof(GLParamBuffer));
+  ob->next=NULL;
+  l->first_op_buffer=ob;
+  ob->ops[0].op=OP_EndList;
+  c->shared_state.lists[list]=l;
+  return l;
+}
+void gl_print_op(FILE *f,GLParam *p)
+{
+  int op;
+  char *s;
+  op=p[0].op;
+  p++;
+  s=op_table_str[op];
+  while (*s != 0) {
+    if (*s == '%') {
+      s++;
+      switch (*s++) {
+      case 'f':
+        fprintf(f,"%g",p[0].f);
+        break;
+      default:
+        fprintf(f,"%d",p[0].i);
+        break;
+      }
+      p++;
+    } else {
+      fputc(*s,f);
+      s++;
+    }
+  }
+  fprintf(f,"\n");
+}
+void gl_compile_op(GLContext *c,GLParam *p)
+{
+  int op,op_size;
+  GLParamBuffer *ob,*ob1;
+  int index,i;
+  op=p[0].op;
+  op_size=op_table_size[op];
+  index=c->current_op_buffer_index;
+  ob=c->current_op_buffer;
+  /* we should be able to add a NextBuffer opcode */
+  if ((index + op_size) > (OP_BUFFER_MAX_SIZE-2)) {
+    ob1=gl_zalloc(sizeof(GLParamBuffer));
+    ob1->next=NULL;
+    ob->next=ob1;
+    ob->ops[index].op=OP_NextBuffer;
+    ob->ops[index+1].p=(void *)ob1;
+    c->current_op_buffer=ob1;
+    ob=ob1;
+    index=0;
+  }
+  for(i=0;i<op_size;i++) {
+    ob->ops[index]=p[i];
+    index++;
+  }
+  c->current_op_buffer_index=index;
+}
+void gl_add_op(GLParam *p)
+{
+  GLContext *c=gl_get_context();
+  int op;
+  op=p[0].op;
+  if (c->exec_flag) {
+    op_table_func[op](c,p);
+  }
+  if (c->compile_flag) {
+    gl_compile_op(c,p);
+  }
+  if (c->print_flag) {
+    gl_print_op(stderr,p);
+  }
+}
+/* this opcode is never called directly */
+void glopEndList(GLContext *c,GLParam *p)
+{
+  assert(0);
+}
+/* this opcode is never called directly */
+void glopNextBuffer(GLContext *c,GLParam *p)
+{
+  assert(0);
+}
+void glopCallList(GLContext *c,GLParam *p)
+{
+  GLList *l;
+  int list,op;
+  list=p[1].ui;
+  l=find_list(c,list);
+  if (l == NULL) gl_fatal_error("list %d not defined",list);
+  p=l->first_op_buffer->ops;
+  while (1) {
+    op=p[0].op;
+    if (op == OP_EndList) break;
+    if (op == OP_NextBuffer) {
+      p=(GLParam *)p[1].p;
+    } else {
+      op_table_func[op](c,p);
+      p+=op_table_size[op];
+    }
+  }
+}
+void glNewList(unsigned int list,int mode)
+{
+  GLList *l;
+  GLContext *c=gl_get_context();
+  assert(mode == GL_COMPILE || mode == GL_COMPILE_AND_EXECUTE);
+  assert(c->compile_flag == 0);
+  l=find_list(c,list);
+  if (l!=NULL) delete_list(c,list);
+  l=alloc_list(c,list);
+  c->current_op_buffer=l->first_op_buffer;
+  c->current_op_buffer_index=0;
+  c->compile_flag=1;
+  c->exec_flag=(mode == GL_COMPILE_AND_EXECUTE);
+}
+void glEndList(void)
+{
+  GLContext *c=gl_get_context();
+  GLParam p[1];
+  assert(c->compile_flag == 1);
+  /* end of list */
+  p[0].op=OP_EndList;
+  gl_compile_op(c,p);
+  c->compile_flag=0;
+  c->exec_flag=1;
+}
+int glIsList(unsigned int list)
+{
+  GLContext *c=gl_get_context();
+  GLList *l;
+  l=find_list(c,list);
+  return (l != NULL);
+}
+unsigned int glGenLists(int range)
+{
+  GLContext *c=gl_get_context();
+  int count,i,list;
+  GLList **lists;
+  lists=c->shared_state.lists;
+  count=0;
+  for(i=0;i<MAX_DISPLAY_LISTS;i++) {
+    if (lists[i]==NULL) {
+      count++;
+      if (count == range) {
+        list=i-range+1;
+        for(i=0;i<range;i++) {
+          alloc_list(c,list+i);
+        }
+        return list;
+      }
+    } else {
+      count=0;
+    }
+  }
+  return 0;
+}

 /programs/develop/libraries/TinyGL/src/matrix.c
 ,0 → 1,241
+#include "zgl.h"
+void gl_print_matrix( const float *m)
+{
+   int i;
+   for (i=0;i<4;i++) {
+      fprintf(stderr,"%f %f %f %f\n", m[i], m[4+i], m[8+i], m[12+i] );
+   }
+}
+static inline void gl_matrix_update(GLContext *c)
+{
+  c->matrix_model_projection_updated=(c->matrix_mode<=1);
+}
+void glopMatrixMode(GLContext *c,GLParam *p)
+{
+  int mode=p[1].i;
+  switch(mode) {
+  case GL_MODELVIEW:
+    c->matrix_mode=0;
+    break;
+  case GL_PROJECTION:
+    c->matrix_mode=1;
+    break;
+  case GL_TEXTURE:
+    c->matrix_mode=2;
+    break;
+  default:
+    assert(0);
+  }
+}
+void glopLoadMatrix(GLContext *c,GLParam *p)
+{
+  M4 *m;
+  int i;
+  GLParam *q;
+  m=c->matrix_stack_ptr[c->matrix_mode];
+  q=p+1;
+  for(i=0;i<4;i++) {
+    m->m[0][i]=q[0].f;
+    m->m[1][i]=q[1].f;
+    m->m[2][i]=q[2].f;
+    m->m[3][i]=q[3].f;
+    q+=4;
+  }
+  gl_matrix_update(c);
+}
+void glopLoadIdentity(GLContext *c,GLParam *p)
+{
+  gl_M4_Id(c->matrix_stack_ptr[c->matrix_mode]);
+  gl_matrix_update(c);
+}
+void glopMultMatrix(GLContext *c,GLParam *p)
+{
+  M4 m;
+  int i;
+  GLParam *q;
+  q=p+1;
+  for(i=0;i<4;i++) {
+    m.m[0][i]=q[0].f;
+    m.m[1][i]=q[1].f;
+    m.m[2][i]=q[2].f;
+    m.m[3][i]=q[3].f;
+    q+=4;
+  }
+  gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
+  gl_matrix_update(c);
+}
+void glopPushMatrix(GLContext *c,GLParam *p)
+{
+  int n=c->matrix_mode;
+  M4 *m;
+  assert( (c->matrix_stack_ptr[n] - c->matrix_stack[n] + 1 )
+           < c->matrix_stack_depth_max[n] );
+  m=++c->matrix_stack_ptr[n];
+  gl_M4_Move(&m[0],&m[-1]);
+  gl_matrix_update(c);
+}
+void glopPopMatrix(GLContext *c,GLParam *p)
+{
+  int n=c->matrix_mode;
+  assert( c->matrix_stack_ptr[n] > c->matrix_stack[n] );
+  c->matrix_stack_ptr[n]--;
+  gl_matrix_update(c);
+}
+void glopRotate(GLContext *c,GLParam *p)
+{
+  M4 m;
+  float u[3];
+  float angle;
+  int dir_code;
+  angle = p[1].f * M_PI / 180.0;
+  u[0]=p[2].f;
+  u[1]=p[3].f;
+  u[2]=p[4].f;
+  /* simple case detection */
+  dir_code = ((u[0] != 0)<<2) | ((u[1] != 0)<<1) | (u[2] != 0);
+  switch(dir_code) {
+  case 0:
+    gl_M4_Id(&m);
+    break;
+  case 4:
+    if (u[0] < 0) angle=-angle;
+    gl_M4_Rotate(&m,angle,0);
+    break;
+  case 2:
+    if (u[1] < 0) angle=-angle;
+    gl_M4_Rotate(&m,angle,1);
+    break;
+  case 1:
+    if (u[2] < 0) angle=-angle;
+    gl_M4_Rotate(&m,angle,2);
+    break;
+  default:
+    {
+      float cost, sint;
+      /* normalize vector */
+      float len = u[0]*u[0]+u[1]*u[1]+u[2]*u[2];
+      if (len == 0.0f) return;
+      len = 1.0f / sqrt(len);
+      u[0] *= len;
+      u[1] *= len;
+      u[2] *= len;
+      /* store cos and sin values */
+      cost=cos(angle);
+      sint=sin(angle);
+      /* fill in the values */
+      m.m[3][0]=m.m[3][1]=m.m[3][2]=
+        m.m[0][3]=m.m[1][3]=m.m[2][3]=0.0f;
+      m.m[3][3]=1.0f;
+      /* do the math */
+      m.m[0][0]=u[0]*u[0]+cost*(1-u[0]*u[0]);
+      m.m[1][0]=u[0]*u[1]*(1-cost)-u[2]*sint;
+      m.m[2][0]=u[2]*u[0]*(1-cost)+u[1]*sint;
+      m.m[0][1]=u[0]*u[1]*(1-cost)+u[2]*sint;
+      m.m[1][1]=u[1]*u[1]+cost*(1-u[1]*u[1]);
+      m.m[2][1]=u[1]*u[2]*(1-cost)-u[0]*sint;
+      m.m[0][2]=u[2]*u[0]*(1-cost)-u[1]*sint;
+      m.m[1][2]=u[1]*u[2]*(1-cost)+u[0]*sint;
+      m.m[2][2]=u[2]*u[2]+cost*(1-u[2]*u[2]);
+    }
+  }
+  gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
+  gl_matrix_update(c);
+}
+void glopScale(GLContext *c,GLParam *p)
+{
+  float *m;
+  float x=p[1].f,y=p[2].f,z=p[3].f;
+  m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
+  m[0] *= x;   m[1] *= y;   m[2]  *= z;
+  m[4] *= x;   m[5] *= y;   m[6]  *= z;
+  m[8] *= x;   m[9] *= y;   m[10] *= z;
+  m[12] *= x;   m[13] *= y;   m[14] *= z;
+  gl_matrix_update(c);
+}
+void glopTranslate(GLContext *c,GLParam *p)
+{
+  float *m;
+  float x=p[1].f,y=p[2].f,z=p[3].f;
+  m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
+  m[3] = m[0] * x + m[1] * y + m[2]  * z + m[3];
+  m[7] = m[4] * x + m[5] * y + m[6]  * z + m[7];
+  m[11] = m[8] * x + m[9] * y + m[10] * z + m[11];
+  m[15] = m[12] * x + m[13] * y + m[14] * z + m[15];
+  gl_matrix_update(c);
+}
+void glopFrustum(GLContext *c,GLParam *p)
+{
+  float *r;
+  M4 m;
+  float left=p[1].f;
+  float right=p[2].f;
+  float bottom=p[3].f;
+  float top=p[4].f;
+  float near=p[5].f;
+  float farp=p[6].f;
+  float x,y,A,B,C,D;
+  x = (2.0*near) / (right-left);
+  y = (2.0*near) / (top-bottom);
+  A = (right+left) / (right-left);
+  B = (top+bottom) / (top-bottom);
+  C = -(farp+near) / ( farp-near);
+  D = -(2.0*farp*near) / (farp-near);
+  r=&m.m[0][0];
+  r[0]= x; r[1]=0; r[2]=A; r[3]=0;
+  r[4]= 0; r[5]=y; r[6]=B; r[7]=0;
+  r[8]= 0; r[9]=0; r[10]=C; r[11]=D;
+  r[12]= 0; r[13]=0; r[14]=-1; r[15]=0;
+  gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
+  gl_matrix_update(c);
+}

 /programs/develop/libraries/TinyGL/src/misc.c
 ,0 → 1,147
+#include "zgl.h"
+#include "msghandling.h"
+void glopViewport(GLContext *c,GLParam *p)
+{
+  int xsize,ysize,xmin,ymin,xsize_req,ysize_req;
+  xmin=p[1].i;
+  ymin=p[2].i;
+  xsize=p[3].i;
+  ysize=p[4].i;
+  /* we may need to resize the zbuffer */
+  if (c->viewport.xmin != xmin ||
+      c->viewport.ymin != ymin ||
+      c->viewport.xsize != xsize ||
+      c->viewport.ysize != ysize) {
+    xsize_req=xmin+xsize;
+    ysize_req=ymin+ysize;
+    if (c->gl_resize_viewport &&
+        c->gl_resize_viewport(c,&xsize_req,&ysize_req) != 0) {
+      gl_fatal_error("glViewport: error while resizing display");
+    }
+    xsize=xsize_req-xmin;
+    ysize=ysize_req-ymin;
+    if (xsize <= 0 || ysize <= 0) {
+      gl_fatal_error("glViewport: size too small");
+    }
+    tgl_trace("glViewport: %d %d %d %d\n",
+              xmin, ymin, xsize, ysize);
+    c->viewport.xmin=xmin;
+    c->viewport.ymin=ymin;
+    c->viewport.xsize=xsize;
+    c->viewport.ysize=ysize;
+    c->viewport.updated=1;
+  }
+}
+void glopEnableDisable(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  int v=p[2].i;
+  switch(code) {
+  case GL_CULL_FACE:
+    c->cull_face_enabled=v;
+    break;
+  case GL_LIGHTING:
+    c->lighting_enabled=v;
+    break;
+  case GL_COLOR_MATERIAL:
+    c->color_material_enabled=v;
+      break;
+  case GL_TEXTURE_2D:
+    c->texture_2d_enabled=v;
+    break;
+  case GL_NORMALIZE:
+    c->normalize_enabled=v;
+    break;
+  case GL_DEPTH_TEST:
+    c->depth_test = v;
+    break;
+  case GL_POLYGON_OFFSET_FILL:
+    if (v) c->offset_states |= TGL_OFFSET_FILL;
+    else c->offset_states &= ~TGL_OFFSET_FILL;
+    break;
+  case GL_POLYGON_OFFSET_POINT:
+    if (v) c->offset_states |= TGL_OFFSET_POINT;
+    else c->offset_states &= ~TGL_OFFSET_POINT;
+    break;
+  case GL_POLYGON_OFFSET_LINE:
+    if (v) c->offset_states |= TGL_OFFSET_LINE;
+    else c->offset_states &= ~TGL_OFFSET_LINE;
+    break;
+  default:
+    if (code>=GL_LIGHT0 && code<GL_LIGHT0+MAX_LIGHTS) {
+      gl_enable_disable_light(c,code - GL_LIGHT0, v);
+    } else {
+      /*
+      fprintf(stderr,"glEnableDisable: 0x%X not supported.\n",code);
+      */
+    }
+    break;
+  }
+}
+void glopShadeModel(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  c->current_shade_model=code;
+}
+void glopCullFace(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  c->current_cull_face=code;
+}
+void glopFrontFace(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  c->current_front_face=code;
+}
+void glopPolygonMode(GLContext *c,GLParam *p)
+{
+  int face=p[1].i;
+  int mode=p[2].i;
+  switch(face) {
+  case GL_BACK:
+    c->polygon_mode_back=mode;
+    break;
+  case GL_FRONT:
+    c->polygon_mode_front=mode;
+    break;
+  case GL_FRONT_AND_BACK:
+    c->polygon_mode_front=mode;
+    c->polygon_mode_back=mode;
+    break;
+  default:
+    assert(0);
+  }
+}
+void glopHint(GLContext *c,GLParam *p)
+{
+#if 0
+  int target=p[1].i;
+  int mode=p[2].i;
+  /* do nothing */
+#endif
+}
+void
+glopPolygonOffset(GLContext *c, GLParam *p)
+{
+  c->offset_factor = p[1].f;
+  c->offset_units = p[2].f;
+}

 /programs/develop/libraries/TinyGL/src/msghandling.c
 ,0 → 1,52
+#include <stdarg.h>
+#include <stdio.h>
+#define NDEBUG
+#ifdef NDEBUG
+#define NO_DEBUG_OUTPUT
+#endif
+/* Use this function to output messages when something unexpected
+   happens (which might be an indication of an error). *Don't* use it
+   when there's internal errors in the code - these should be handled
+   by asserts. */
+void
+tgl_warning(const char *format, ...)
+{
+#ifndef NO_DEBUG_OUTPUT
+  va_list args;
+  va_start(args, format);
+  fprintf(stderr, "*WARNING* ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+#endif /* !NO_DEBUG_OUTPUT */
+}
+/* This function should be used for debug output only. */
+void
+tgl_trace(const char *format, ...)
+{
+#ifndef NO_DEBUG_OUTPUT
+  va_list args;
+  va_start(args, format);
+  fprintf(stderr, "*DEBUG* ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+#endif /* !NO_DEBUG_OUTPUT */
+}
+/* Use this function to output info about things in the code which
+   should be fixed (missing handling of special cases, important
+   features not implemented, known bugs/buglets, ...). */
+void
+tgl_fixme(const char *format, ...)
+{
+#ifndef NO_DEBUG_OUTPUT
+  va_list args;
+  va_start(args, format);
+  fprintf(stderr, "*FIXME* ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+#endif /* !NO_DEBUG_OUTPUT */
+}

 /programs/develop/libraries/TinyGL/src/msghandling.h
 ,0 → 1,8
+#ifndef _msghandling_h_
+#define _msghandling_h_
+extern void tgl_warning(const char *text, ...);
+extern void tgl_trace(const char *text, ...);
+extern void tgl_fixme(const char *text, ...);
+#endif /* _msghandling_h_ */

 /programs/develop/libraries/TinyGL/src/opinfo.h
 ,0 → 1,71
+ADD_OP(Color,7,"%f %f %f %f %d %d %d")
+ADD_OP(TexCoord,4,"%f %f %f %f")
+ADD_OP(EdgeFlag,1,"%d")
+ADD_OP(Normal,3,"%f %f %f")
+ADD_OP(Begin,1,"%C")
+ADD_OP(Vertex,4,"%f %f %f %f")
+ADD_OP(End,0,"")
+ADD_OP(EnableDisable,2,"%C %d")
+ADD_OP(MatrixMode,1,"%C")
+ADD_OP(LoadMatrix,16,"")
+ADD_OP(LoadIdentity,0,"")
+ADD_OP(MultMatrix,16,"")
+ADD_OP(PushMatrix,0,"")
+ADD_OP(PopMatrix,0,"")
+ADD_OP(Rotate,4,"%f %f %f %f")
+ADD_OP(Translate,3,"%f %f %f")
+ADD_OP(Scale,3,"%f %f %f")
+ADD_OP(Viewport,4,"%d %d %d %d")
+ADD_OP(Frustum,6,"%f %f %f %f %f %f")
+ADD_OP(Material,6,"%C %C %f %f %f %f")
+ADD_OP(ColorMaterial,2,"%C %C")
+ADD_OP(Light,6,"%C %C %f %f %f %f")
+ADD_OP(LightModel,5,"%C %f %f %f %f")
+ADD_OP(Clear,1,"%d")
+ADD_OP(ClearColor,4,"%f %f %f %f")
+ADD_OP(ClearDepth,1,"%f")
+ADD_OP(InitNames,0,"")
+ADD_OP(PushName,1,"%d")
+ADD_OP(PopName,0,"")
+ADD_OP(LoadName,1,"%d")
+ADD_OP(TexImage2D,9,"%d %d %d %d %d %d %d %d %d")
+ADD_OP(BindTexture,2,"%C %d")
+ADD_OP(TexEnv,7,"%C %C %C %f %f %f %f")
+ADD_OP(TexParameter,7,"%C %C %C %f %f %f %f")
+ADD_OP(PixelStore,2,"%C %C")
+ADD_OP(ShadeModel,1,"%C")
+ADD_OP(CullFace,1,"%C")
+ADD_OP(FrontFace,1,"%C")
+ADD_OP(PolygonMode,2,"%C %C")
+ADD_OP(CallList,1,"%d")
+ADD_OP(Hint,2,"%C %C")
+/* special opcodes */
+ADD_OP(EndList,0,"")
+ADD_OP(NextBuffer,1,"%p")
+/* opengl 1.1 arrays */
+ADD_OP(ArrayElement, 1, "%d")
+ADD_OP(EnableClientState, 1, "%C")
+ADD_OP(DisableClientState, 1, "%C")
+ADD_OP(VertexPointer, 4, "%d %C %d %p")
+ADD_OP(ColorPointer, 4, "%d %C %d %p")
+ADD_OP(NormalPointer, 3, "%C %d %p")
+ADD_OP(TexCoordPointer, 4, "%d %C %d %p")
+/* opengl 1.1 polygon offset */
+ADD_OP(PolygonOffset, 2, "%f %f")
+#undef ADD_OP

 /programs/develop/libraries/TinyGL/src/select.c
 ,0 → 1,114
+#include "zgl.h"
+int glRenderMode(int mode)
+{
+  GLContext *c=gl_get_context();
+  int result=0;
+  switch(c->render_mode) {
+  case GL_RENDER:
+    break;
+  case GL_SELECT:
+    if (c->select_overflow) {
+      result=-c->select_hits;
+    } else {
+      result=c->select_hits;
+    }
+    c->select_overflow=0;
+    c->select_ptr=c->select_buffer;
+    c->name_stack_size=0;
+    break;
+  default:
+    assert(0);
+  }
+  switch(mode) {
+  case GL_RENDER:
+    c->render_mode=GL_RENDER;
+    break;
+  case GL_SELECT:
+    c->render_mode=GL_SELECT;
+    assert( c->select_buffer != NULL);
+    c->select_ptr=c->select_buffer;
+    c->select_hits=0;
+    c->select_overflow=0;
+    c->select_hit=NULL;
+    break;
+  default:
+    assert(0);
+  }
+  return result;
+}
+void glSelectBuffer(int size,unsigned int *buf)
+{
+  GLContext *c=gl_get_context();
+  assert(c->render_mode != GL_SELECT);
+  c->select_buffer=buf;
+  c->select_size=size;
+}
+void glopInitNames(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+    c->name_stack_size=0;
+    c->select_hit=NULL;
+  }
+}
+void glopPushName(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+    assert(c->name_stack_size<MAX_NAME_STACK_DEPTH);
+    c->name_stack[c->name_stack_size++]=p[1].i;
+    c->select_hit=NULL;
+  }
+}
+void glopPopName(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+    assert(c->name_stack_size>0);
+    c->name_stack_size--;
+    c->select_hit=NULL;
+  }
+}
+void glopLoadName(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+   assert(c->name_stack_size>0);
+   c->name_stack[c->name_stack_size-1]=p[1].i;
+   c->select_hit=NULL;
+  }
+}
+void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax)
+{
+  unsigned int *ptr;
+  int n,i;
+  if (!c->select_overflow) {
+    if (c->select_hit==NULL) {
+      n=c->name_stack_size;
+      if ((c->select_ptr-c->select_buffer+3+n) >
+          c->select_size) {
+        c->select_overflow=1;
+      } else {
+        ptr=c->select_ptr;
+        c->select_hit=ptr;
+        *ptr++=c->name_stack_size;
+        *ptr++=zmin;
+        *ptr++=zmax;
+        for(i=0;i<n;i++) *ptr++=c->name_stack[i];
+        c->select_ptr=ptr;
+        c->select_hits++;
+      }
+    } else {
+      if (zmin<c->select_hit[1]) c->select_hit[1]=zmin;
+      if (zmax>c->select_hit[2]) c->select_hit[2]=zmax;
+    }
+  }
+}

 /programs/develop/libraries/TinyGL/src/specbuf.c
 ,0 → 1,52
+#include "zgl.h"
+#include "msghandling.h"
+#include <math.h>
+#include <stdlib.h>
+static void calc_buf(GLSpecBuf *buf, const float shininess)
+{
+  int i;
+  float val, inc;
+  val = 0.0f;
+  inc = 1.0f/SPECULAR_BUFFER_SIZE;
+  for (i = 0; i <= SPECULAR_BUFFER_SIZE; i++) {
+    buf->buf[i] = pow(val, shininess);
+    val += inc;
+  }
+}
+GLSpecBuf *
+specbuf_get_buffer(GLContext *c, const int shininess_i,
+                   const float shininess)
+{
+  GLSpecBuf *found, *oldest;
+  found = oldest = c->specbuf_first;
+  while (found && found->shininess_i != shininess_i) {
+    if (found->last_used < oldest->last_used) {
+      oldest = found;
+    }
+    found = found->next;
+  }
+  if (found) { /* hey, found one! */
+    found->last_used = c->specbuf_used_counter++;
+    return found;
+  }
+  if (oldest == NULL || c->specbuf_num_buffers < MAX_SPECULAR_BUFFERS) {
+    /* create new buffer */
+    GLSpecBuf *buf = gl_malloc(sizeof(GLSpecBuf));
+    if (!buf) gl_fatal_error("could not allocate specular buffer");
+    c->specbuf_num_buffers++;
+    buf->next = c->specbuf_first;
+    c->specbuf_first = buf;
+    buf->last_used = c->specbuf_used_counter++;
+    buf->shininess_i = shininess_i;
+    calc_buf(buf, shininess);
+    return buf;
+  }
+  /* overwrite the lru buffer */
+  /*tgl_trace("overwriting spec buffer :(\n");*/
+  oldest->shininess_i = shininess_i;
+  oldest->last_used = c->specbuf_used_counter++;
+  calc_buf(oldest, shininess);
+  return oldest;
+}

 /programs/develop/libraries/TinyGL/src/specbuf.h
 ,0 → 1,22
+#ifndef _tgl_specbuf_h_
+#define _tgl_specbuf_h_
+/* Max # of specular light pow buffers */
+#define MAX_SPECULAR_BUFFERS 8
+/* # of entries in specular buffer */
+#define SPECULAR_BUFFER_SIZE 1024
+/* specular buffer granularity */
+#define SPECULAR_BUFFER_RESOLUTION 1024
+typedef struct GLSpecBuf {
+  int shininess_i;
+  int last_used;
+  float buf[SPECULAR_BUFFER_SIZE+1];
+  struct GLSpecBuf *next;
+} GLSpecBuf;
+GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i,
+                              const float shininess);
+void specbuf_cleanup(GLContext *c); /* free all memory used */
+#endif /* _tgl_specbuf_h_ */

 /programs/develop/libraries/TinyGL/src/texture.c
 ,0 → 1,229
+/*
+ * Texture Manager
+ */
+#include "zgl.h"
+static GLTexture *find_texture(GLContext *c,int h)
+{
+  GLTexture *t;
+  t=c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE];
+  while (t!=NULL) {
+    if (t->handle == h) return t;
+    t=t->next;
+  }
+  return NULL;
+}
+static void free_texture(GLContext *c,int h)
+{
+  GLTexture *t,**ht;
+  GLImage *im;
+  int i;
+  t=find_texture(c,h);
+  if (t->prev==NULL) {
+    ht=&c->shared_state.texture_hash_table
+      [t->handle % TEXTURE_HASH_TABLE_SIZE];
+    *ht=t->next;
+  } else {
+    t->prev->next=t->next;
+  }
+  if (t->next!=NULL) t->next->prev=t->prev;
+  for(i=0;i<MAX_TEXTURE_LEVELS;i++) {
+    im=&t->images[i];
+    if (im->pixmap != NULL) gl_free(im->pixmap);
+  }
+  gl_free(t);
+}
+GLTexture *alloc_texture(GLContext *c,int h)
+{
+  GLTexture *t,**ht;
+  t=gl_zalloc(sizeof(GLTexture));
+  ht=&c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE];
+  t->next=*ht;
+  t->prev=NULL;
+  if (t->next != NULL) t->next->prev=t;
+  *ht=t;
+  t->handle=h;
+  return t;
+}
+void glInitTextures(GLContext *c)
+{
+  /* textures */
+  c->texture_2d_enabled=0;
+  c->current_texture=find_texture(c,0);
+}
+void glGenTextures(int n, unsigned int *textures)
+{
+  GLContext *c=gl_get_context();
+  int max,i;
+  GLTexture *t;
+  max=0;
+  for(i=0;i<TEXTURE_HASH_TABLE_SIZE;i++) {
+    t=c->shared_state.texture_hash_table[i];
+    while (t!=NULL) {
+      if (t->handle>max) max=t->handle;
+      t=t->next;
+    }
+  }
+  for(i=0;i<n;i++) {
+    textures[i]=max+i+1;
+  }
+}
+void glDeleteTextures(int n, const unsigned int *textures)
+{
+  GLContext *c=gl_get_context();
+  int i;
+  GLTexture *t;
+  for(i=0;i<n;i++) {
+    t=find_texture(c,textures[i]);
+    if (t!=NULL && t!=0) {
+      if (t==c->current_texture) {
+        glBindTexture(GL_TEXTURE_2D,0);
+      }
+      free_texture(c,textures[i]);
+    }
+  }
+}
+void glopBindTexture(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int texture=p[2].i;
+  GLTexture *t;
+  assert(target == GL_TEXTURE_2D && texture >= 0);
+  t=find_texture(c,texture);
+  if (t==NULL) {
+    t=alloc_texture(c,texture);
+  }
+  c->current_texture=t;
+}
+void glopTexImage2D(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int level=p[2].i;
+  int components=p[3].i;
+  int width=p[4].i;
+  int height=p[5].i;
+  int border=p[6].i;
+  int format=p[7].i;
+  int type=p[8].i;
+  void *pixels=p[9].p;
+  GLImage *im;
+  unsigned char *pixels1;
+  int do_free;
+  if (!(target == GL_TEXTURE_2D && level == 0 && components == 3 &&
+        border == 0 && format == GL_RGB &&
+        type == GL_UNSIGNED_BYTE)) {
+    gl_fatal_error("glTexImage2D: combinaison of parameters not handled");
+  }
+  do_free=0;
+  if (width != 256 || height != 256) {
+    pixels1 = gl_malloc(256 * 256 * 3);
+    /* no interpolation is done here to respect the original image aliasing ! */
+    gl_resizeImageNoInterpolate(pixels1,256,256,pixels,width,height);
+    do_free=1;
+    width=256;
+    height=256;
+  } else {
+    pixels1=pixels;
+  }
+  im=&c->current_texture->images[level];
+  im->xsize=width;
+  im->ysize=height;
+  if (im->pixmap!=NULL) gl_free(im->pixmap);
+#if TGL_FEATURE_RENDER_BITS == 24
+  im->pixmap=gl_malloc(width*height*3);
+  if(im->pixmap) {
+      memcpy(im->pixmap,pixels1,width*height*3);
+  }
+#elif TGL_FEATURE_RENDER_BITS == 32
+  im->pixmap=gl_malloc(width*height*4);
+  if(im->pixmap) {
+      gl_convertRGB_to_8A8R8G8B(im->pixmap,pixels1,width,height);
+  }
+#elif TGL_FEATURE_RENDER_BITS == 16
+  im->pixmap=gl_malloc(width*height*2);
+  if(im->pixmap) {
+      gl_convertRGB_to_5R6G5B(im->pixmap,pixels1,width,height);
+  }
+#else
+#error TODO
+#endif
+  if (do_free) gl_free(pixels1);
+}
+/* TODO: not all tests are done */
+void glopTexEnv(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int pname=p[2].i;
+  int param=p[3].i;
+  if (target != GL_TEXTURE_ENV) {
+  error:
+    gl_fatal_error("glTexParameter: unsupported option");
+  }
+  if (pname != GL_TEXTURE_ENV_MODE) goto error;
+  if (param != GL_DECAL) goto error;
+}
+/* TODO: not all tests are done */
+void glopTexParameter(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int pname=p[2].i;
+  int param=p[3].i;
+  if (target != GL_TEXTURE_2D) {
+  error:
+    gl_fatal_error("glTexParameter: unsupported option");
+  }
+  switch(pname) {
+  case GL_TEXTURE_WRAP_S:
+  case GL_TEXTURE_WRAP_T:
+    if (param != GL_REPEAT) goto error;
+    break;
+  }
+}
+void glopPixelStore(GLContext *c,GLParam *p)
+{
+  int pname=p[1].i;
+  int param=p[2].i;
+  if (pname != GL_UNPACK_ALIGNMENT ||
+      param != 1) {
+    gl_fatal_error("glPixelStore: unsupported option");
+  }
+}

 /programs/develop/libraries/TinyGL/src/vertex.c
 ,0 → 1,364
+#include "zgl.h"
+void glopNormal(GLContext * c, GLParam * p)
+{
+    V3 v;
+    v.X = p[1].f;
+    v.Y = p[2].f;
+    v.Z = p[3].f;
+    c->current_normal.X = v.X;
+    c->current_normal.Y = v.Y;
+    c->current_normal.Z = v.Z;
+    c->current_normal.W = 0;
+}
+void glopTexCoord(GLContext * c, GLParam * p)
+{
+    c->current_tex_coord.X = p[1].f;
+    c->current_tex_coord.Y = p[2].f;
+    c->current_tex_coord.Z = p[3].f;
+    c->current_tex_coord.W = p[4].f;
+}
+void glopEdgeFlag(GLContext * c, GLParam * p)
+{
+    c->current_edge_flag = p[1].i;
+}
+void glopColor(GLContext * c, GLParam * p)
+{
+    c->current_color.X = p[1].f;
+    c->current_color.Y = p[2].f;
+    c->current_color.Z = p[3].f;
+    c->current_color.W = p[4].f;
+    c->longcurrent_color[0] = p[5].ui;
+    c->longcurrent_color[1] = p[6].ui;
+    c->longcurrent_color[2] = p[7].ui;
+    if (c->color_material_enabled) {
+        GLParam q[7];
+        q[0].op = OP_Material;
+        q[1].i = c->current_color_material_mode;
+        q[2].i = c->current_color_material_type;
+        q[3].f = p[1].f;
+        q[4].f = p[2].f;
+        q[5].f = p[3].f;
+        q[6].f = p[4].f;
+        glopMaterial(c, q);
+    }
+}
+void gl_eval_viewport(GLContext * c)
+{
+    GLViewport *v;
+    float zsize = (1 << (ZB_Z_BITS + ZB_POINT_Z_FRAC_BITS));
+    v = &c->viewport;
+    v->trans.X = ((v->xsize - 0.5) / 2.0) + v->xmin;
+    v->trans.Y = ((v->ysize - 0.5) / 2.0) + v->ymin;
+    v->trans.Z = ((zsize - 0.5) / 2.0) + ((1 << ZB_POINT_Z_FRAC_BITS)) / 2;
+    v->scale.X = (v->xsize - 0.5) / 2.0;
+    v->scale.Y = -(v->ysize - 0.5) / 2.0;
+    v->scale.Z = -((zsize - 0.5) / 2.0);
+}
+void glopBegin(GLContext * c, GLParam * p)
+{
+    int type;
+    M4 tmp;
+    assert(c->in_begin == 0);
+    type = p[1].i;
+    c->begin_type = type;
+    c->in_begin = 1;
+    c->vertex_n = 0;
+    c->vertex_cnt = 0;
+    if (c->matrix_model_projection_updated) {
+        if (c->lighting_enabled) {
+            /* precompute inverse modelview */
+            gl_M4_Inv(&tmp, c->matrix_stack_ptr[0]);
+            gl_M4_Transpose(&c->matrix_model_view_inv, &tmp);
+        } else {
+            float *m = &c->matrix_model_projection.m[0][0];
+            /* precompute projection matrix */
+            gl_M4_Mul(&c->matrix_model_projection,
+                      c->matrix_stack_ptr[1],
+                      c->matrix_stack_ptr[0]);
+            /* test to accelerate computation */
+            c->matrix_model_projection_no_w_transform = 0;
+            if (m[12] == 0.0 && m[13] == 0.0 && m[14] == 0.0)
+                c->matrix_model_projection_no_w_transform = 1;
+        }
+        /* test if the texture matrix is not Identity */
+        c->apply_texture_matrix = !gl_M4_IsId(c->matrix_stack_ptr[2]);
+        c->matrix_model_projection_updated = 0;
+    }
+    /*  viewport */
+    if (c->viewport.updated) {
+        gl_eval_viewport(c);
+        c->viewport.updated = 0;
+    }
+    /* triangle drawing functions */
+    if (c->render_mode == GL_SELECT) {
+        c->draw_triangle_front = gl_draw_triangle_select;
+        c->draw_triangle_back = gl_draw_triangle_select;
+    } else {
+        switch (c->polygon_mode_front) {
+        case GL_POINT:
+            c->draw_triangle_front = gl_draw_triangle_point;
+            break;
+        case GL_LINE:
+            c->draw_triangle_front = gl_draw_triangle_line;
+            break;
+        default:
+            c->draw_triangle_front = gl_draw_triangle_fill;
+            break;
+        }
+        switch (c->polygon_mode_back) {
+        case GL_POINT:
+            c->draw_triangle_back = gl_draw_triangle_point;
+            break;
+        case GL_LINE:
+            c->draw_triangle_back = gl_draw_triangle_line;
+            break;
+        default:
+            c->draw_triangle_back = gl_draw_triangle_fill;
+            break;
+        }
+    }
+}
+/* coords, tranformation , clip code and projection */
+/* TODO : handle all cases */
+static inline void gl_vertex_transform(GLContext * c, GLVertex * v)
+{
+    float *m;
+    V4 *n;
+    if (c->lighting_enabled) {
+        /* eye coordinates needed for lighting */
+        m = &c->matrix_stack_ptr[0]->m[0][0];
+        v->ec.X = (v->coord.X * m[0] + v->coord.Y * m[1] +
+                   v->coord.Z * m[2] + m[3]);
+        v->ec.Y = (v->coord.X * m[4] + v->coord.Y * m[5] +
+                   v->coord.Z * m[6] + m[7]);
+        v->ec.Z = (v->coord.X * m[8] + v->coord.Y * m[9] +
+                   v->coord.Z * m[10] + m[11]);
+        v->ec.W = (v->coord.X * m[12] + v->coord.Y * m[13] +
+                   v->coord.Z * m[14] + m[15]);
+        /* projection coordinates */
+        m = &c->matrix_stack_ptr[1]->m[0][0];
+        v->pc.X = (v->ec.X * m[0] + v->ec.Y * m[1] +
+                   v->ec.Z * m[2] + v->ec.W * m[3]);
+        v->pc.Y = (v->ec.X * m[4] + v->ec.Y * m[5] +
+                   v->ec.Z * m[6] + v->ec.W * m[7]);
+        v->pc.Z = (v->ec.X * m[8] + v->ec.Y * m[9] +
+                   v->ec.Z * m[10] + v->ec.W * m[11]);
+        v->pc.W = (v->ec.X * m[12] + v->ec.Y * m[13] +
+                   v->ec.Z * m[14] + v->ec.W * m[15]);
+        m = &c->matrix_model_view_inv.m[0][0];
+        n = &c->current_normal;
+        v->normal.X = (n->X * m[0] + n->Y * m[1] + n->Z * m[2]);
+        v->normal.Y = (n->X * m[4] + n->Y * m[5] + n->Z * m[6]);
+        v->normal.Z = (n->X * m[8] + n->Y * m[9] + n->Z * m[10]);
+        if (c->normalize_enabled) {
+            gl_V3_Norm(&v->normal);
+        }
+    } else {
+        /* no eye coordinates needed, no normal */
+        /* NOTE: W = 1 is assumed */
+        m = &c->matrix_model_projection.m[0][0];
+        v->pc.X = (v->coord.X * m[0] + v->coord.Y * m[1] +
+                   v->coord.Z * m[2] + m[3]);
+        v->pc.Y = (v->coord.X * m[4] + v->coord.Y * m[5] +
+                   v->coord.Z * m[6] + m[7]);
+        v->pc.Z = (v->coord.X * m[8] + v->coord.Y * m[9] +
+                   v->coord.Z * m[10] + m[11]);
+        if (c->matrix_model_projection_no_w_transform) {
+            v->pc.W = m[15];
+        } else {
+            v->pc.W = (v->coord.X * m[12] + v->coord.Y * m[13] +
+                       v->coord.Z * m[14] + m[15]);
+        }
+    }
+    v->clip_code = gl_clipcode(v->pc.X, v->pc.Y, v->pc.Z, v->pc.W);
+}
+void glopVertex(GLContext * c, GLParam * p)
+{
+    GLVertex *v;
+    int n, i, cnt;
+    assert(c->in_begin != 0);
+    n = c->vertex_n;
+    cnt = c->vertex_cnt;
+    cnt++;
+    c->vertex_cnt = cnt;
+    /* quick fix to avoid crashes on large polygons */
+    if (n >= c->vertex_max) {
+        GLVertex *newarray;
+        c->vertex_max <<= 1;    /* just double size */
+        newarray = gl_malloc(sizeof(GLVertex) * c->vertex_max);
+        if (!newarray) {
+            gl_fatal_error("unable to allocate GLVertex array.\n");
+        }
+        memcpy(newarray, c->vertex, n * sizeof(GLVertex));
+        gl_free(c->vertex);
+        c->vertex = newarray;
+    }
+    /* new vertex entry */
+    v = &c->vertex[n];
+    n++;
+    v->coord.X = p[1].f;
+    v->coord.Y = p[2].f;
+    v->coord.Z = p[3].f;
+    v->coord.W = p[4].f;
+    gl_vertex_transform(c, v);
+    /* color */
+    if (c->lighting_enabled) {
+        gl_shade_vertex(c, v);
+    } else {
+        v->color = c->current_color;
+    }
+    /* tex coords */
+    if (c->texture_2d_enabled) {
+        if (c->apply_texture_matrix) {
+            gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord);
+        } else {
+            v->tex_coord = c->current_tex_coord;
+        }
+    }
+    /* precompute the mapping to the viewport */
+    if (v->clip_code == 0)
+        gl_transform_to_viewport(c, v);
+        /* edge flag */
+    v->edge_flag = c->current_edge_flag;
+    switch (c->begin_type) {
+    case GL_POINTS:
+        gl_draw_point(c, &c->vertex[0]);
+        n = 0;
+        break;
+    case GL_LINES:
+        if (n == 2) {
+            gl_draw_line(c, &c->vertex[0], &c->vertex[1]);
+            n = 0;
+        }
+        break;
+    case GL_LINE_STRIP:
+    case GL_LINE_LOOP:
+        if (n == 1) {
+            c->vertex[2] = c->vertex[0];
+        } else if (n == 2) {
+            gl_draw_line(c, &c->vertex[0], &c->vertex[1]);
+            c->vertex[0] = c->vertex[1];
+            n = 1;
+        }
+        break;
+    case GL_TRIANGLES:
+        if (n == 3) {
+                gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+            n = 0;
+        }
+        break;
+    case GL_TRIANGLE_STRIP:
+        if (cnt >= 3) {
+            if (n == 3)
+                n = 0;
+            /* needed to respect triangle orientation */
+            switch(cnt & 1) {
+            case 0:
+                gl_draw_triangle(c,&c->vertex[2],&c->vertex[1],&c->vertex[0]);
+                break;
+            default:
+            case 1:
+                gl_draw_triangle(c,&c->vertex[0],&c->vertex[1],&c->vertex[2]);
+                break;
+            }
+        }
+        break;
+    case GL_TRIANGLE_FAN:
+        if (n == 3) {
+            gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+            c->vertex[1] = c->vertex[2];
+            n = 2;
+        }
+        break;
+    case GL_QUADS:
+        if (n == 4) {
+            c->vertex[2].edge_flag = 0;
+            gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+            c->vertex[2].edge_flag = 1;
+            c->vertex[0].edge_flag = 0;
+            gl_draw_triangle(c, &c->vertex[0], &c->vertex[2], &c->vertex[3]);
+            n = 0;
+        }
+        break;
+    case GL_QUAD_STRIP:
+        if (n == 4) {
+            gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+            gl_draw_triangle(c, &c->vertex[1], &c->vertex[3], &c->vertex[2]);
+            for (i = 0; i < 2; i++)
+                c->vertex[i] = c->vertex[i + 2];
+            n = 2;
+        }
+        break;
+    case GL_POLYGON:
+        break;
+    default:
+        gl_fatal_error("glBegin: type %x not handled\n", c->begin_type);
+    }
+    c->vertex_n = n;
+}
+void glopEnd(GLContext * c, GLParam * param)
+{
+    assert(c->in_begin == 1);
+    if (c->begin_type == GL_LINE_LOOP) {
+        if (c->vertex_cnt >= 3) {
+            gl_draw_line(c, &c->vertex[0], &c->vertex[2]);
+        }
+    } else if (c->begin_type == GL_POLYGON) {
+        int i = c->vertex_cnt;
+        while (i >= 3) {
+            i--;
+            gl_draw_triangle(c, &c->vertex[i], &c->vertex[0], &c->vertex[i - 1]);
+        }
+    }
+    c->in_begin = 0;
+}

 /programs/develop/libraries/TinyGL/src/zbuffer.c
 ,0 → 1,509
+/*
+ * Z buffer: 16 bits Z / 16 bits color
+ *
+ */
+#include <stdlib.h>
+#include <stdio.h>
+/*#include <assert.h>*/
+#include <string.h>
+#include "zbuffer.h"
+ZBuffer *ZB_open(int xsize, int ysize, int mode,
+                 int nb_colors,
+                 unsigned char *color_indexes,
+                 int *color_table,
+                 void *frame_buffer)
+{
+    ZBuffer *zb;
+    int size;
+    zb = gl_malloc(sizeof(ZBuffer));
+    if (zb == NULL)
+        return NULL;
+    zb->xsize = xsize;
+    zb->ysize = ysize;
+    zb->mode = mode;
+    zb->linesize = (xsize * PSZB + 3) & ~3;
+    switch (mode) {
+#ifdef TGL_FEATURE_8_BITS
+    case ZB_MODE_INDEX:
+        ZB_initDither(zb, nb_colors, color_indexes, color_table);
+        break;
+#endif
+#ifdef TGL_FEATURE_32_BITS
+    case ZB_MODE_RGBA:
+#endif
+#ifdef TGL_FEATURE_24_BITS
+    case ZB_MODE_RGB24:
+#endif
+    case ZB_MODE_5R6G5B:
+        zb->nb_colors = 0;
+        break;
+    default:
+        goto error;
+    }
+    size = zb->xsize * zb->ysize * sizeof(unsigned short);
+    zb->zbuf = gl_malloc(size);
+    if (zb->zbuf == NULL)
+        goto error;
+        zb->frame_buffer_allocated = 0;
+        zb->pbuf = NULL;
+    zb->current_texture = NULL;
+    return zb;
+  error:
+    gl_free(zb);
+    return NULL;
+}
+void ZB_close(ZBuffer * zb)
+{
+#ifdef TGL_FEATURE_8_BITS
+    if (zb->mode == ZB_MODE_INDEX)
+        ZB_closeDither(zb);
+#endif
+    if (zb->frame_buffer_allocated)
+        gl_free(zb->pbuf);
+    gl_free(zb->zbuf);
+    gl_free(zb);
+}
+void ZB_resize(ZBuffer * zb, void *frame_buffer, int xsize, int ysize)
+{
+    int size;
+    /* xsize must be a multiple of 4 */
+    xsize = xsize & ~3;
+    zb->xsize = xsize;
+    zb->ysize = ysize;
+    zb->linesize = (xsize * PSZB + 3) & ~3;
+    size = zb->xsize * zb->ysize * sizeof(unsigned short);
+    gl_free(zb->zbuf);
+    zb->zbuf = gl_malloc(size);
+    if (zb->frame_buffer_allocated)
+        gl_free(zb->pbuf);
+    if (frame_buffer == NULL) {
+        zb->pbuf = gl_malloc((zb->ysize+1) * (zb->linesize));
+        zb->frame_buffer_allocated = 1;
+    } else {
+        zb->pbuf = frame_buffer;
+        zb->frame_buffer_allocated = 0;
+    }
+}
+static void ZB_copyBuffer(ZBuffer * zb,
+                          void *buf,
+                          int linesize)
+{
+    unsigned char *p1;
+    PIXEL *q;
+    int y, n;
+    q = zb->pbuf;
+    p1 = buf;
+    n = zb->xsize * PSZB;
+    for (y = 0; y < zb->ysize; y++) {
+        memcpy(p1, q, n);
+        p1 += linesize;
+        q = (PIXEL *) ((char *) q + zb->linesize);
+    }
+}
+#if TGL_FEATURE_RENDER_BITS == 16
+/* 32 bpp copy */
+#ifdef TGL_FEATURE_32_BITS
+#define RGB16_TO_RGB32(p0,p1,v)\
+{\
+    unsigned int g,b,gb;\
+    g = (v & 0x07E007E0) << 5;\
+    b = (v & 0x001F001F) << 3;\
+    gb = g | b;\
+    p0 = (gb & 0x0000FFFF) | ((v & 0x0000F800) << 8);\
+    p1 = (gb >> 16) | ((v & 0xF8000000) >> 8);\
+}
+static void ZB_copyFrameBufferRGB32(ZBuffer * zb,
+                                    void *buf,
+                                    int linesize)
+{
+    unsigned short *q;
+    unsigned int *p, *p1, v, w0, w1;
+    int y, n;
+    q = zb->pbuf;
+    p1 = (unsigned int *) buf;
+    for (y = 0; y < zb->ysize; y++) {
+        p = p1;
+        n = zb->xsize >> 2;
+        do {
+            v = *(unsigned int *) q;
+#if BYTE_ORDER == BIG_ENDIAN
+            RGB16_TO_RGB32(w1, w0, v);
+#else
+            RGB16_TO_RGB32(w0, w1, v);
+#endif
+            p[0] = w0;
+            p[1] = w1;
+            v = *(unsigned int *) (q + 2);
+#if BYTE_ORDER == BIG_ENDIAN
+            RGB16_TO_RGB32(w1, w0, v);
+#else
+            RGB16_TO_RGB32(w0, w1, v);
+#endif
+            p[2] = w0;
+            p[3] = w1;
+            q += 4;
+            p += 4;
+        } while (--n > 0);
+        p1 += linesize;
+    }
+}
+#endif
+/* 24 bit packed pixel handling */
+#ifdef TGL_FEATURE_24_BITS
+/* order: RGBR GBRG BRGB */
+/* XXX: packed pixel 24 bit support not tested */
+/* XXX: big endian case not optimised */
+#if BYTE_ORDER == BIG_ENDIAN
+#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\
+{\
+    unsigned int r1,g1,b1,gb1,g2,b2,gb2;\
+    v1 = (v1 << 16) | (v1 >> 16);\
+    v2 = (v2 << 16) | (v2 >> 16);\
+    r1 = (v1 & 0xF800F800);\
+    g1 = (v1 & 0x07E007E0) << 5;\
+    b1 = (v1 & 0x001F001F) << 3;\
+    gb1 = g1 | b1;\
+    p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\
+    g2 = (v2 & 0x07E007E0) << 5;\
+    b2 = (v2 & 0x001F001F) << 3;\
+    gb2 = g2 | b2;\
+    p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\
+    p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\
+}
+#else
+#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\
+{\
+    unsigned int r1,g1,b1,gb1,g2,b2,gb2;\
+    r1 = (v1 & 0xF800F800);\
+    g1 = (v1 & 0x07E007E0) << 5;\
+    b1 = (v1 & 0x001F001F) << 3;\
+    gb1 = g1 | b1;\
+    p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\
+    g2 = (v2 & 0x07E007E0) << 5;\
+    b2 = (v2 & 0x001F001F) << 3;\
+    gb2 = g2 | b2;\
+    p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\
+    p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\
+}
+#endif
+static void ZB_copyFrameBufferRGB24(ZBuffer * zb,
+                                    void *buf,
+                                    int linesize)
+{
+    unsigned short *q;
+    unsigned int *p, *p1, w0, w1, w2, v0, v1;
+    int y, n;
+    q = zb->pbuf;
+    p1 = (unsigned int *) buf;
+    linesize = linesize * 3;
+    for (y = 0; y < zb->ysize; y++) {
+        p = p1;
+        n = zb->xsize >> 2;
+        do {
+            v0 = *(unsigned int *) q;
+            v1 = *(unsigned int *) (q + 2);
+            RGB16_TO_RGB24(w0, w1, w2, v0, v1);
+            p[0] = w0;
+            p[1] = w1;
+            p[2] = w2;
+            q += 4;
+            p += 3;
+        } while (--n > 0);
+        (char *) p1 += linesize;
+    }
+}
+#endif
+void ZB_copyFrameBuffer(ZBuffer * zb, void *buf,
+                        int linesize)
+{
+    switch (zb->mode) {
+#ifdef TGL_FEATURE_8_BITS
+    case ZB_MODE_INDEX:
+        ZB_ditherFrameBuffer(zb, buf, linesize >> 1);
+        break;
+#endif
+#ifdef TGL_FEATURE_16_BITS
+    case ZB_MODE_5R6G5B:
+        ZB_copyBuffer(zb, buf, linesize);
+        break;
+#endif
+#ifdef TGL_FEATURE_32_BITS
+    case ZB_MODE_RGBA:
+        ZB_copyFrameBufferRGB32(zb, buf, linesize >> 1);
+        break;
+#endif
+#ifdef TGL_FEATURE_24_BITS
+    case ZB_MODE_RGB24:
+        ZB_copyFrameBufferRGB24(zb, buf, linesize >> 1);
+        break;
+#endif
+    default:
+        assert(0);
+    }
+}
+#endif /* TGL_FEATURE_RENDER_BITS == 16 */
+#if TGL_FEATURE_RENDER_BITS == 24
+#define RGB24_TO_RGB16(r, g, b) \
+  ((((r) >> 3) << 11) | (((g) >> 2) << 5) | ((b) >> 3))
+/* XXX: not optimized */
+static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb,
+                                     void *buf, int linesize)
+{
+    PIXEL *q;
+    unsigned short *p, *p1;
+    int y, n;
+    q = zb->pbuf;
+    p1 = (unsigned short *) buf;
+    for (y = 0; y < zb->ysize; y++) {
+        p = p1;
+        n = zb->xsize >> 2;
+        do {
+            p[0] = RGB24_TO_RGB16(q[0], q[1], q[2]);
+            p[1] = RGB24_TO_RGB16(q[3], q[4], q[5]);
+            p[2] = RGB24_TO_RGB16(q[6], q[7], q[8]);
+            p[3] = RGB24_TO_RGB16(q[9], q[10], q[11]);
+            q = (PIXEL *)((char *)q + 4 * PSZB);
+            p += 4;
+        } while (--n > 0);
+        p1 = (unsigned short *)((char *)p1 + linesize);
+    }
+}
+void ZB_copyFrameBuffer(ZBuffer * zb, void *buf,
+                        int linesize)
+{
+    switch (zb->mode) {
+#ifdef TGL_FEATURE_16_BITS
+    case ZB_MODE_5R6G5B:
+        ZB_copyFrameBuffer5R6G5B(zb, buf, linesize);
+        break;
+#endif
+#ifdef TGL_FEATURE_24_BITS
+    case ZB_MODE_RGB24:
+        ZB_copyBuffer(zb, buf, linesize);
+        break;
+#endif
+    default:
+        assert(0);
+    }
+}
+#endif /* TGL_FEATURE_RENDER_BITS == 24 */
+#if TGL_FEATURE_RENDER_BITS == 32
+#define RGB32_TO_RGB16(v) \
+  (((v >> 8) & 0xf800) | (((v) >> 5) & 0x07e0) | (((v) & 0xff) >> 3))
+/* XXX: not optimized */
+static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb,
+                                     void *buf, int linesize)
+{
+    PIXEL *q;
+    unsigned short *p, *p1;
+    int y, n;
+    q = zb->pbuf;
+    p1 = (unsigned short *) buf;
+    for (y = 0; y < zb->ysize; y++) {
+        p = p1;
+        n = zb->xsize >> 2;
+        do {
+            p[0] = RGB32_TO_RGB16(q[0]);
+            p[1] = RGB32_TO_RGB16(q[1]);
+            p[2] = RGB32_TO_RGB16(q[2]);
+            p[3] = RGB32_TO_RGB16(q[3]);
+            q += 4;
+            p += 4;
+        } while (--n > 0);
+        p1 = (unsigned short *)((char *)p1 + linesize);
+    }
+}
+void ZB_copyFrameBuffer(ZBuffer * zb, void *buf,
+                        int linesize)
+{
+    switch (zb->mode) {
+#ifdef TGL_FEATURE_16_BITS
+    case ZB_MODE_5R6G5B:
+        ZB_copyFrameBuffer5R6G5B(zb, buf, linesize);
+        break;
+#endif
+#ifdef TGL_FEATURE_32_BITS
+    case ZB_MODE_RGBA:
+        ZB_copyBuffer(zb, buf, linesize);
+        break;
+#endif
+    default:
+        assert(0);
+    }
+}
+#endif /* TGL_FEATURE_RENDER_BITS == 32 */
+/*
+ * adr must be aligned on an 'int'
+ */
+void memset_s(void *adr, int val, int count)
+{
+    int i, n, v;
+    unsigned int *p;
+    unsigned short *q;
+    p = adr;
+    v = val | (val << 16);
+    n = count >> 3;
+    for (i = 0; i < n; i++) {
+        p[0] = v;
+        p[1] = v;
+        p[2] = v;
+        p[3] = v;
+        p += 4;
+    }
+    q = (unsigned short *) p;
+    n = count & 7;
+    for (i = 0; i < n; i++)
+        *q++ = val;
+}
+void memset_l(void *adr, int val, int count)
+{
+    int i, n, v;
+    unsigned int *p;
+    p = adr;
+    v = val;
+    n = count >> 2;
+    for (i = 0; i < n; i++) {
+        p[0] = v;
+        p[1] = v;
+        p[2] = v;
+        p[3] = v;
+        p += 4;
+    }
+    n = count & 3;
+    for (i = 0; i < n; i++)
+        *p++ = val;
+}
+/* count must be a multiple of 4 and >= 4 */
+void memset_RGB24(void *adr,int r, int v, int b,long count)
+{
+    long i, n;
+    register long v1,v2,v3,*pt=(long *)(adr);
+    unsigned char *p,R=(unsigned char)r,V=(unsigned char)v,B=(unsigned char)b;
+    p=(unsigned char *)adr;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    v1=*pt++;
+    v2=*pt++;
+    v3=*pt++;
+    n = count >> 2;
+    for(i=1;i<n;i++) {
+        *pt++=v1;
+        *pt++=v2;
+        *pt++=v3;
+    }
+}
+void ZB_clear(ZBuffer * zb, int clear_z, int z,
+              int clear_color, int r, int g, int b)
+{
+#if TGL_FEATURE_RENDER_BITS != 24
+    int color;
+#endif
+    int y;
+    PIXEL *pp;
+    if (clear_z) {
+        memset_s(zb->zbuf, z, zb->xsize * zb->ysize);
+    }
+    if (clear_color) {
+        pp = zb->pbuf;
+        for (y = 0; y < zb->ysize; y++) {
+#if TGL_FEATURE_RENDER_BITS == 15 || TGL_FEATURE_RENDER_BITS == 16
+            color = RGB_TO_PIXEL(r, g, b);
+            memset_s(pp, color, zb->xsize);
+#elif TGL_FEATURE_RENDER_BITS == 32
+            color = RGB_TO_PIXEL(r, g, b);
+            memset_l(pp, color, zb->xsize);
+#elif TGL_FEATURE_RENDER_BITS == 24
+            memset_RGB24(pp,r>>8,g>>8,b>>8,zb->xsize);
+#else
+#error TODO
+#endif
+            pp = (PIXEL *) ((char *) pp + zb->linesize);
+        }
+    }
+}

 /programs/develop/libraries/TinyGL/src/zbuffer.h
 ,0 → 1,169
+#ifndef _tgl_zbuffer_h_
+#define _tgl_zbuffer_h_
+/*
+ * Z buffer
+ */
+#include "zfeatures.h"
+#define ZB_Z_BITS 16
+#define ZB_POINT_Z_FRAC_BITS 14
+#define ZB_POINT_S_MIN ( (1<<13) )
+#define ZB_POINT_S_MAX ( (1<<22)-(1<<13) )
+#define ZB_POINT_T_MIN ( (1<<21) )
+#define ZB_POINT_T_MAX ( (1<<30)-(1<<21) )
+#define ZB_POINT_RED_MIN ( (1<<10) )
+#define ZB_POINT_RED_MAX ( (1<<16)-(1<<10) )
+#define ZB_POINT_GREEN_MIN ( (1<<9) )
+#define ZB_POINT_GREEN_MAX ( (1<<16)-(1<<9) )
+#define ZB_POINT_BLUE_MIN ( (1<<10) )
+#define ZB_POINT_BLUE_MAX ( (1<<16)-(1<<10) )
+/* display modes */
+#define ZB_MODE_5R6G5B  1  /* true color 16 bits */
+#define ZB_MODE_INDEX   2  /* color index 8 bits */
+#define ZB_MODE_RGBA    3  /* 32 bit rgba mode */
+#define ZB_MODE_RGB24   4  /* 24 bit rgb mode */
+#define ZB_NB_COLORS    225 /* number of colors for 8 bit display */
+#if TGL_FEATURE_RENDER_BITS == 15
+#define RGB_TO_PIXEL(r,g,b) \
+  ((((r) >> 1) & 0x7c00) | (((g) >> 6) & 0x03e0) | ((b) >> 11))
+typedef unsigned short PIXEL;
+/* bytes per pixel */
+#define PSZB 2
+/* bits per pixel = (1 << PSZH) */
+#define PSZSH 4
+#elif TGL_FEATURE_RENDER_BITS == 16
+/* 16 bit mode */
+#define RGB_TO_PIXEL(r,g,b) \
+  (((r) & 0xF800) | (((g) >> 5) & 0x07E0) | ((b) >> 11))
+typedef unsigned short PIXEL;
+#define PSZB 2
+#define PSZSH 4
+#elif TGL_FEATURE_RENDER_BITS == 24
+#define RGB_TO_PIXEL(r,g,b) \
+  ((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8))
+typedef unsigned char PIXEL;
+#define PSZB 3
+#define PSZSH 5
+#elif TGL_FEATURE_RENDER_BITS == 32
+#define RGB_TO_PIXEL(r,g,b) \
+  ((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8))
+typedef unsigned int PIXEL;
+#define PSZB 4
+#define PSZSH 5
+#else
+#error Incorrect number of bits per pixel
+#endif
+typedef struct {
+    int xsize,ysize;
+    int linesize; /* line size, in bytes */
+    int mode;
+    unsigned short *zbuf;
+    PIXEL *pbuf;
+    int frame_buffer_allocated;
+    int nb_colors;
+    unsigned char *dctable;
+    int *ctable;
+    PIXEL *current_texture;
+} ZBuffer;
+typedef struct {
+  int x,y,z;     /* integer coordinates in the zbuffer */
+  int s,t;       /* coordinates for the mapping */
+  int r,g,b;     /* color indexes */
+  float sz,tz;   /* temporary coordinates for mapping */
+} ZBufferPoint;
+/* zbuffer.c */
+ZBuffer *ZB_open(int xsize,int ysize,int mode,
+                 int nb_colors,
+                 unsigned char *color_indexes,
+                 int *color_table,
+                 void *frame_buffer);
+void ZB_close(ZBuffer *zb);
+void ZB_resize(ZBuffer *zb,void *frame_buffer,int xsize,int ysize);
+void ZB_clear(ZBuffer *zb,int clear_z,int z,
+              int clear_color,int r,int g,int b);
+/* linesize is in BYTES */
+void ZB_copyFrameBuffer(ZBuffer *zb,void *buf,int linesize);
+/* zdither.c */
+void ZB_initDither(ZBuffer *zb,int nb_colors,
+                   unsigned char *color_indexes,int *color_table);
+void ZB_closeDither(ZBuffer *zb);
+void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *dest,
+                          int linesize);
+/* zline.c */
+void ZB_plot(ZBuffer *zb,ZBufferPoint *p);
+void ZB_line(ZBuffer *zb,ZBufferPoint *p1,ZBufferPoint *p2);
+void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2);
+/* ztriangle.c */
+void ZB_setTexture(ZBuffer *zb, PIXEL *texture);
+void ZB_fillTriangleFlat(ZBuffer *zb,
+                 ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3);
+void ZB_fillTriangleSmooth(ZBuffer *zb,
+                   ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3);
+void ZB_fillTriangleMapping(ZBuffer *zb,
+                    ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3);
+void ZB_fillTriangleMappingPerspective(ZBuffer *zb,
+                    ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2);
+typedef void (*ZB_fillTriangleFunc)(ZBuffer  *,
+            ZBufferPoint *,ZBufferPoint *,ZBufferPoint *);
+/*
+ * Memory allocator for TinyGL
+ */
+/* modify these functions so that they suit your needs */
+static inline void gl_free(void *p)
+{
+    free(p);
+}
+static inline void *gl_malloc(int size)
+{
+    return malloc(size);
+}
+static inline void *gl_zalloc(int size)
+{
+    return calloc(1, size);
+}
+#endif /* _tgl_zbuffer_h_ */

 /programs/develop/libraries/TinyGL/src/zdither.c
 ,0 → 1,159
+/*
+ * Highly optimised dithering 16 bits -> 8 bits.
+ * The formulas were taken in Mesa (Bob Mercier mercier@hollywood.cinenet.net).
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include "zbuffer.h"
+/*#include <assert.h>*/
+#if defined(TGL_FEATURE_8_BITS)
+#define _R      5
+#define _G      9
+#define _B      5
+#define _DX     4
+#define _DY     4
+#define _D      (_DX*_DY)
+#define _MIX(r,g,b)     ( ((g)<<6) | ((b)<<3) | (r) )
+#define DITHER_TABLE_SIZE (1 << 15)
+#define DITHER_INDEX(r,g,b) ((b) + (g) * _B + (r) * (_B * _G))
+#define MAXC    256
+static int kernel8[_DY*_DX] = {
+* MAXC,  8 * MAXC,  2 * MAXC, 10 * MAXC,
+* MAXC,  4 * MAXC, 14 * MAXC,  6 * MAXC,
+* MAXC, 11 * MAXC,  1 * MAXC,  9 * MAXC,
+* MAXC,  7 * MAXC, 13 * MAXC,  5 * MAXC,
+};
+/* we build the color table and the lookup table */
+void ZB_initDither(ZBuffer *zb,int nb_colors,
+                   unsigned char *color_indexes,int *color_table)
+{
+  int c,r,g,b,i,index,r1,g1,b1;
+  if (nb_colors < (_R * _G * _B)) {
+    fprintf(stderr,"zdither: not enough colors\n");
+    exit(1);
+  }
+  for(i=0;i<nb_colors;i++) color_table[i]=0;
+  zb->nb_colors=nb_colors;
+  zb->ctable=gl_malloc(nb_colors * sizeof(int));
+  for (r = 0; r < _R; r++) {
+    for (g = 0; g < _G; g++) {
+      for (b = 0; b < _B; b++) {
+        r1=(r*255) / (_R - 1);
+        g1=(g*255) / (_G - 1);
+        b1=(b*255) / (_B - 1);
+        index=DITHER_INDEX(r,g,b);
+        c=(r1 << 16) | (g1 << 8) | b1;
+        zb->ctable[index]=c;
+        color_table[index]=c;
+      }
+    }
+  }
+  zb->dctable=gl_malloc( DITHER_TABLE_SIZE );
+  for(i=0;i<DITHER_TABLE_SIZE;i++) {
+    r=(i >> 12) & 0x7;
+    g=(i >> 8) & 0xF;
+    b=(i >> 3) & 0x7;
+    index=DITHER_INDEX(r,g,b);
+    zb->dctable[i]=color_indexes[index];
+  }
+}
+void ZB_closeDither(ZBuffer *zb)
+{
+    gl_free(zb->ctable);
+    gl_free(zb->dctable);
+}
+#if 0
+int ZDither_lookupColor(int r,int g,int b)
+{
+  unsigned char *ctable=zdither_color_table;
+  return ctable[_MIX(_DITH0(_R, r), _DITH0(_G, g),_DITH0(_B, b))];
+}
+#endif
+#define DITHER_PIXEL2(a)                        \
+{ \
+  register int v,t,r,g,c;                       \
+  v=*(unsigned int *)(pp+(a));                  \
+  g=(v & 0x07DF07DF) + g_d; \
+  r=(((v & 0xF800F800) >> 2) + r_d) & 0x70007000; \
+  t=r | g; \
+  c=ctable[t & 0xFFFF] | (ctable[t >> 16] << 8); \
+  *(unsigned short *)(dest+(a))=c;      \
+}
+/* NOTE: all the memory access are 16 bit aligned, so if buf or
+   linesize are not multiple of 2, it cannot work efficiently (or
+   hang!) */
+void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *buf,
+                          int linesize)
+{
+  int xk,yk,x,y,c1,c2;
+  unsigned char *dest1;
+  unsigned short *pp1;
+  int r_d,g_d,b_d;
+  unsigned char *ctable=zb->dctable;
+  register unsigned char *dest;
+  register unsigned short *pp;
+  assert( ((long)buf & 1) == 0 && (linesize & 1) == 0);
+  for(yk=0;yk<4;yk++) {
+    for(xk=0;xk<4;xk+=2) {
+#if BYTE_ORDER == BIG_ENDIAN
+      c1=kernel8[yk*4+xk+1];
+      c2=kernel8[yk*4+xk];
+#else
+      c1=kernel8[yk*4+xk];
+      c2=kernel8[yk*4+xk+1];
+#endif
+      r_d=((c1 << 2) & 0xF800) >> 2;
+      g_d=(c1 >> 4) & 0x07C0;
+      b_d=(c1 >> 9) & 0x001F;
+      r_d|=(((c2 << 2) & 0xF800) >> 2) << 16;
+      g_d|=((c2 >> 4) & 0x07C0) << 16;
+      b_d|=((c2 >> 9) & 0x001F) << 16;
+      g_d=b_d | g_d;
+      dest1=buf + (yk * linesize) + xk;
+      pp1=zb->pbuf + (yk * zb->xsize) + xk;
+      for(y=yk;y<zb->ysize;y+=4) {
+        dest=dest1;
+        pp=pp1;
+        for(x=xk;x<zb->xsize;x+=16) {
+          DITHER_PIXEL2(0);
+          DITHER_PIXEL2(1*4);
+          DITHER_PIXEL2(2*4);
+          DITHER_PIXEL2(3*4);
+          pp+=16;
+          dest+=16;
+        }
+        dest1+=linesize*4;
+        pp1+=zb->xsize*4;
+      }
+    }
+  }
+}
+#endif

 /programs/develop/libraries/TinyGL/src/zfeatures.h
 ,0 → 1,54
+#ifndef _tgl_features_h_
+#define _tgl_features_h_
+#define NDEBUG
+/*for menuetlibc*/
+#ifdef NDEBUG
+/*
+ * If not debugging, assert does nothing.
+ */
+#define assert(x)       ((void)0)
+#else /* debugging enabled */
+#include <assert.h>
+#endif
+/* It is possible to enable/disable (compile time) features in this
+   header file. */
+/*#define TGL_FEATURE_ARRAYS         1*/
+/*#define TGL_FEATURE_DISPLAYLISTS   1*/
+/*#define TGL_FEATURE_POLYGON_OFFSET 1*/
+/*
+ * Matrix of internal and external pixel formats supported. 'Y' means
+ * supported.
+ *
+ *           External  8    16    24    32
+ * Internal
+ *  15                 .     .     .     .
+ *  16                 Y     Y     Y     Y
+ *  24                 .     Y     Y     .
+ *  32                 .     Y     .     Y
+ *
+ *
+ * 15 bpp does not work yet (although it is easy to add it - ask me if
+ * you need it).
+ *
+ * Internal pixel format: see TGL_FEATURE_RENDER_BITS
+ * External pixel format: see TGL_FEATURE_xxx_BITS
+ */
+/* enable various convertion code from internal pixel format (usually
+bits per pixel) to any external format */
+/*#define TGL_FEATURE_16_BITS        1*/
+/*#define TGL_FEATURE_8_BITS         1*/
+#define TGL_FEATURE_24_BITS        1
+/*#define TGL_FEATURE_32_BITS        1*/
+/*#define TGL_FEATURE_RENDER_BITS    15*/
+/*#define TGL_FEATURE_RENDER_BITS    16*/
+#define TGL_FEATURE_RENDER_BITS    24
+/*#define TGL_FEATURE_RENDER_BITS    32*/
+#endif /* _tgl_features_h_ */

 /programs/develop/libraries/TinyGL/src/zgl.h
 ,0 → 1,392
+#ifndef _tgl_zgl_h_
+#define _tgl_zgl_h_
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+/*#include <assert.h>*/
+#include <GL/gl.h>
+#include "zbuffer.h"
+#include "zmath.h"
+#include "zfeatures.h"
+#define fputc(...) /*nothing*/
+#define fprintf(...) /*nothing*/
+#define vfprintf(...) /*nothing*/
+#undef stderr
+#define stderr ((FILE*)-1)
+/*#define DEBUG */
+/*#define NDEBUG */
+enum {
+#define ADD_OP(a,b,c) OP_ ## a ,
+#include "opinfo.h"
+};
+/* initially # of allocated GLVertexes (will grow when necessary) */
+#define POLYGON_MAX_VERTEX 16
+/* Max # of specular light pow buffers */
+#define MAX_SPECULAR_BUFFERS 8
+/* # of entries in specular buffer */
+#define SPECULAR_BUFFER_SIZE 1024
+/* specular buffer granularity */
+#define SPECULAR_BUFFER_RESOLUTION 1024
+#define MAX_MODELVIEW_STACK_DEPTH  32
+#define MAX_PROJECTION_STACK_DEPTH 8
+#define MAX_TEXTURE_STACK_DEPTH    8
+#define MAX_NAME_STACK_DEPTH       64
+#define MAX_TEXTURE_LEVELS         11
+#define MAX_LIGHTS                 16
+#define VERTEX_HASH_SIZE 1031
+#define MAX_DISPLAY_LISTS 1024
+#define OP_BUFFER_MAX_SIZE 512
+#define TGL_OFFSET_FILL    0x1
+#define TGL_OFFSET_LINE    0x2
+#define TGL_OFFSET_POINT   0x4
+typedef struct GLSpecBuf {
+  int shininess_i;
+  int last_used;
+  float buf[SPECULAR_BUFFER_SIZE+1];
+  struct GLSpecBuf *next;
+} GLSpecBuf;
+typedef struct GLLight {
+  V4 ambient;
+  V4 diffuse;
+  V4 specular;
+  V4 position;
+  V3 spot_direction;
+  float spot_exponent;
+  float spot_cutoff;
+  float attenuation[3];
+  /* precomputed values */
+  float cos_spot_cutoff;
+  V3 norm_spot_direction;
+  V3 norm_position;
+  /* we use a linked list to know which are the enabled lights */
+  int enabled;
+  struct GLLight *next,*prev;
+} GLLight;
+typedef struct GLMaterial {
+  V4 emission;
+  V4 ambient;
+  V4 diffuse;
+  V4 specular;
+  float shininess;
+  /* computed values */
+  int shininess_i;
+  int do_specular;
+} GLMaterial;
+typedef struct GLViewport {
+  int xmin,ymin,xsize,ysize;
+  V3 scale;
+  V3 trans;
+  int updated;
+} GLViewport;
+typedef union {
+  int op;
+  float f;
+  int i;
+  unsigned int ui;
+  void *p;
+} GLParam;
+typedef struct GLParamBuffer {
+  GLParam ops[OP_BUFFER_MAX_SIZE];
+  struct GLParamBuffer *next;
+} GLParamBuffer;
+typedef struct GLList {
+  GLParamBuffer *first_op_buffer;
+  /* TODO: extensions for an hash table or a better allocating scheme */
+} GLList;
+typedef struct GLVertex {
+  int edge_flag;
+  V3 normal;
+  V4 coord;
+  V4 tex_coord;
+  V4 color;
+  /* computed values */
+  V4 ec;                /* eye coordinates */
+  V4 pc;                /* coordinates in the normalized volume */
+  int clip_code;        /* clip code */
+  ZBufferPoint zp;      /* integer coordinates for the rasterization */
+} GLVertex;
+typedef struct GLImage {
+  void *pixmap;
+  int xsize,ysize;
+} GLImage;
+/* textures */
+#define TEXTURE_HASH_TABLE_SIZE 256
+typedef struct GLTexture {
+  GLImage images[MAX_TEXTURE_LEVELS];
+  int handle;
+  struct GLTexture *next,*prev;
+} GLTexture;
+/* shared state */
+typedef struct GLSharedState {
+  GLList **lists;
+  GLTexture **texture_hash_table;
+} GLSharedState;
+struct GLContext;
+typedef void (*gl_draw_triangle_func)(struct GLContext *c,
+                                      GLVertex *p0,GLVertex *p1,GLVertex *p2);
+/* display context */
+typedef struct GLContext {
+  /* Z buffer */
+  ZBuffer *zb;
+  /* lights */
+  GLLight lights[MAX_LIGHTS];
+  GLLight *first_light;
+  V4 ambient_light_model;
+  int local_light_model;
+  int lighting_enabled;
+  int light_model_two_side;
+  /* materials */
+  GLMaterial materials[2];
+  int color_material_enabled;
+  int current_color_material_mode;
+  int current_color_material_type;
+  /* textures */
+  GLTexture *current_texture;
+  int texture_2d_enabled;
+  /* shared state */
+  GLSharedState shared_state;
+  /* current list */
+  GLParamBuffer *current_op_buffer;
+  int current_op_buffer_index;
+  int exec_flag,compile_flag,print_flag;
+  /* matrix */
+  int matrix_mode;
+  M4 *matrix_stack[3];
+  M4 *matrix_stack_ptr[3];
+  int matrix_stack_depth_max[3];
+  M4 matrix_model_view_inv;
+  M4 matrix_model_projection;
+  int matrix_model_projection_updated;
+  int matrix_model_projection_no_w_transform;
+  int apply_texture_matrix;
+  /* viewport */
+  GLViewport viewport;
+  /* current state */
+  int polygon_mode_back;
+  int polygon_mode_front;
+  int current_front_face;
+  int current_shade_model;
+  int current_cull_face;
+  int cull_face_enabled;
+  int normalize_enabled;
+  gl_draw_triangle_func draw_triangle_front,draw_triangle_back;
+  /* selection */
+  int render_mode;
+  unsigned int *select_buffer;
+  int select_size;
+  unsigned int *select_ptr,*select_hit;
+  int select_overflow;
+  int select_hits;
+  /* names */
+  unsigned int name_stack[MAX_NAME_STACK_DEPTH];
+  int name_stack_size;
+  /* clear */
+  float clear_depth;
+  V4 clear_color;
+  /* current vertex state */
+  V4 current_color;
+  unsigned int longcurrent_color[3]; /* precomputed integer color */
+  V4 current_normal;
+  V4 current_tex_coord;
+  int current_edge_flag;
+  /* glBegin / glEnd */
+  int in_begin;
+  int begin_type;
+  int vertex_n,vertex_cnt;
+  int vertex_max;
+  GLVertex *vertex;
+  /* opengl 1.1 arrays  */
+  float *vertex_array;
+  int vertex_array_size;
+  int vertex_array_stride;
+  float *normal_array;
+  int normal_array_stride;
+  float *color_array;
+  int color_array_size;
+  int color_array_stride;
+  float *texcoord_array;
+  int texcoord_array_size;
+  int texcoord_array_stride;
+  int client_states;
+  /* opengl 1.1 polygon offset */
+  float offset_factor;
+  float offset_units;
+  int offset_states;
+  /* specular buffer. could probably be shared between contexts,
+    but that wouldn't be 100% thread safe */
+  GLSpecBuf *specbuf_first;
+  int specbuf_used_counter;
+  int specbuf_num_buffers;
+  /* opaque structure for user's use */
+  void *opaque;
+  /* resize viewport function */
+  int (*gl_resize_viewport)(struct GLContext *c,int *xsize,int *ysize);
+  /* depth test */
+  int depth_test;
+} GLContext;
+extern GLContext *gl_ctx;
+void gl_add_op(GLParam *p);
+/* clip.c */
+void gl_transform_to_viewport(GLContext *c,GLVertex *v);
+void gl_draw_triangle(GLContext *c,GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_line(GLContext *c,GLVertex *p0,GLVertex *p1);
+void gl_draw_point(GLContext *c,GLVertex *p0);
+void gl_draw_triangle_point(GLContext *c,
+                            GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_triangle_line(GLContext *c,
+                           GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_triangle_fill(GLContext *c,
+                           GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_triangle_select(GLContext *c,
+                             GLVertex *p0,GLVertex *p1,GLVertex *p2);
+/* matrix.c */
+void gl_print_matrix(const float *m);
+/*
+void glopLoadIdentity(GLContext *c,GLParam *p);
+void glopTranslate(GLContext *c,GLParam *p);*/
+/* light.c */
+void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax);
+void gl_enable_disable_light(GLContext *c,int light,int v);
+void gl_shade_vertex(GLContext *c,GLVertex *v);
+void glInitTextures(GLContext *c);
+void glEndTextures(GLContext *c);
+GLTexture *alloc_texture(GLContext *c,int h);
+/* image_util.c */
+void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb,
+                             int xsize,int ysize);
+void gl_convertRGB_to_8A8R8G8B(unsigned int *pixmap, unsigned char *rgb,
+                               int xsize, int ysize);
+void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest,
+                    unsigned char *src,int xsize_src,int ysize_src);
+void gl_resizeImageNoInterpolate(unsigned char *dest,int xsize_dest,int ysize_dest,
+                                 unsigned char *src,int xsize_src,int ysize_src);
+static inline GLContext *gl_get_context(void)
+{
+  return gl_ctx;
+};
+void gl_fatal_error(char *format, ...);
+/* specular buffer "api" */
+GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i,
+                              const float shininess);
+#ifdef __BEOS__
+void dprintf(const char *, ...);
+#else /* !BEOS */
+#ifdef DEBUG
+#define dprintf(format, args...)  \
+  fprintf(stderr,"In '%s': " format "\n",__FUNCTION__, ##args);
+#else
+#define dprintf(format, args...)
+#endif
+#endif /* !BEOS */
+/* glopXXX functions */
+#define ADD_OP(a,b,c) void glop ## a (GLContext *,GLParam *);
+#include "opinfo.h"
+/* this clip epsilon is needed to avoid some rounding errors after
+   several clipping stages */
+#define CLIP_EPSILON (1E-5)
+static inline int gl_clipcode(float x,float y,float z,float w1)
+{
+  float w;
+  w=w1 * (1.0 + CLIP_EPSILON);
+  return (x<-w) |
+    ((x>w)<<1) |
+    ((y<-w)<<2) |
+    ((y>w)<<3) |
+    ((z<-w)<<4) |
+    ((z>w)<<5) ;
+}
+#define RGBFtoRGBI(rf,gf,bf,ri,gi,bi) \
+{\
+  ri = (unsigned int) (rf * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + \
+                            ZB_POINT_RED_MIN); \
+  gi = (unsigned int) (gf * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + \
+                            ZB_POINT_GREEN_MIN); \
+  bi = (unsigned int) (bf * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + \
+                            ZB_POINT_BLUE_MIN);\
+}
+#endif /* _tgl_zgl_h_ */

 /programs/develop/libraries/TinyGL/src/zline.c
 ,0 → 1,84
+#include <stdlib.h>
+#include "zbuffer.h"
+#define ZCMP(z,zpix) ((z) >= (zpix))
+void ZB_plot(ZBuffer * zb, ZBufferPoint * p)
+{
+    unsigned short *pz;
+    PIXEL *pp;
+    int zz;
+    pz = zb->zbuf + (p->y * zb->xsize + p->x);
+    pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p->y + p->x * PSZB);
+    zz = p->z >> ZB_POINT_Z_FRAC_BITS;
+    if (ZCMP(zz, *pz)) {
+#if TGL_FEATURE_RENDER_BITS == 24
+        pp[0]=p->r>>8;
+        pp[1]=p->g>>8;
+        pp[2]=p->b>>8;
+#else
+        *pp = RGB_TO_PIXEL(p->r, p->g, p->b);
+#endif
+        *pz = zz;
+    }
+}
+#define INTERP_Z
+static void ZB_line_flat_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2,
+                           int color)
+{
+#include "zline.h"
+}
+/* line with color interpolation */
+#define INTERP_Z
+#define INTERP_RGB
+static void ZB_line_interp_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+#include "zline.h"
+}
+/* no Z interpolation */
+static void ZB_line_flat(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2,
+                             int color)
+{
+#include "zline.h"
+}
+#define INTERP_RGB
+static void ZB_line_interp(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+#include "zline.h"
+}
+void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+    int color1, color2;
+    color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b);
+    color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b);
+    /* choose if the line should have its color interpolated or not */
+    if (color1 == color2) {
+        ZB_line_flat_z(zb, p1, p2, color1);
+    } else {
+        ZB_line_interp_z(zb, p1, p2);
+    }
+}
+void ZB_line(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+    int color1, color2;
+    color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b);
+    color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b);
+    /* choose if the line should have its color interpolated or not */
+    if (color1 == color2) {
+        ZB_line_flat(zb, p1, p2, color1);
+    } else {
+        ZB_line_interp(zb, p1, p2);
+    }
+}

 /programs/develop/libraries/TinyGL/src/zline.h
 ,0 → 1,121
+{
+    int n, dx, dy, sx, pp_inc_1, pp_inc_2;
+    register int a;
+    register PIXEL *pp;
+#if defined(INTERP_RGB) || TGL_FEATURE_RENDER_BITS == 24
+    register unsigned int r, g, b;
+#endif
+#ifdef INTERP_RGB
+    register unsigned int rinc, ginc, binc;
+#endif
+#ifdef INTERP_Z
+    register unsigned short *pz;
+    int zinc;
+    register int z, zz;
+#endif
+    if (p1->y > p2->y || (p1->y == p2->y && p1->x > p2->x)) {
+        ZBufferPoint *tmp;
+        tmp = p1;
+        p1 = p2;
+        p2 = tmp;
+    }
+    sx = zb->xsize;
+    pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p1->y + p1->x * PSZB);
+#ifdef INTERP_Z
+    pz = zb->zbuf + (p1->y * sx + p1->x);
+    z = p1->z;
+#endif
+    dx = p2->x - p1->x;
+    dy = p2->y - p1->y;
+#ifdef INTERP_RGB
+    r = p1->r << 8;
+    g = p1->g << 8;
+    b = p1->b << 8;
+#elif TGL_FEATURE_RENDER_BITS == 24
+    /* for 24 bits, we store the colors in different variables */
+    r = p2->r >> 8;
+    g = p2->g >> 8;
+    b = p2->b >> 8;
+#endif
+#ifdef INTERP_RGB
+#define RGB(x) x
+#if TGL_FEATURE_RENDER_BITS == 24
+#define RGBPIXEL pp[0] = r >> 16, pp[1] = g >> 16, pp[2] = b >> 16
+#else
+#define RGBPIXEL *pp = RGB_TO_PIXEL(r >> 8,g >> 8,b >> 8)
+#endif
+#else /* INTERP_RGB */
+#define RGB(x)
+#if TGL_FEATURE_RENDER_BITS == 24
+#define RGBPIXEL pp[0] = r, pp[1] = g, pp[2] = b
+#else
+#define RGBPIXEL *pp = color
+#endif
+#endif /* INTERP_RGB */
+#ifdef INTERP_Z
+#define ZZ(x) x
+#define PUTPIXEL()                              \
+  {                                             \
+    zz=z >> ZB_POINT_Z_FRAC_BITS;               \
+    if (ZCMP(zz,*pz))  {                        \
+      RGBPIXEL; \
+      *pz=zz;                                   \
+    }                                           \
+  }
+#else /* INTERP_Z */
+#define ZZ(x)
+#define PUTPIXEL() RGBPIXEL
+#endif /* INTERP_Z */
+#define DRAWLINE(dx,dy,inc_1,inc_2) \
+    n=dx;\
+    ZZ(zinc=(p2->z-p1->z)/n);\
+    RGB(rinc=((p2->r-p1->r) << 8)/n;\
+        ginc=((p2->g-p1->g) << 8)/n;\
+        binc=((p2->b-p1->b) << 8)/n);\
+    a=2*dy-dx;\
+    dy=2*dy;\
+    dx=2*dx-dy;\
+    pp_inc_1 = (inc_1) * PSZB;\
+    pp_inc_2 = (inc_2) * PSZB;\
+    do {\
+        PUTPIXEL();\
+        ZZ(z+=zinc);\
+        RGB(r+=rinc;g+=ginc;b+=binc);\
+        if (a>0) { pp=(PIXEL *)((char *)pp + pp_inc_1); ZZ(pz+=(inc_1));  a-=dx; }\
+        else { pp=(PIXEL *)((char *)pp + pp_inc_2); ZZ(pz+=(inc_2)); a+=dy; }\
+    } while (--n >= 0);
+/* fin macro */
+    if (dx == 0 && dy == 0) {
+        PUTPIXEL();
+    } else if (dx > 0) {
+        if (dx >= dy) {
+            DRAWLINE(dx, dy, sx + 1, 1);
+        } else {
+            DRAWLINE(dy, dx, sx + 1, sx);
+        }
+    } else {
+        dx = -dx;
+        if (dx >= dy) {
+            DRAWLINE(dx, dy, sx - 1, -1);
+        } else {
+            DRAWLINE(dy, dx, sx - 1, sx);
+        }
+    }
+}
+#undef INTERP_Z
+#undef INTERP_RGB
+/* internal defines */
+#undef DRAWLINE
+#undef PUTPIXEL
+#undef ZZ
+#undef RGB
+#undef RGBPIXEL

 /programs/develop/libraries/TinyGL/src/zmath.c
 ,0 → 1,274
+/* Some simple mathematical functions. Don't look for some logic in
+   the function names :-) */
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "zmath.h"
+/* ******* Gestion des matrices 4x4 ****** */
+void gl_M4_Id(M4 *a)
+{
+        int i,j;
+        for(i=0;i<4;i++)
+        for(j=0;j<4;j++)
+        if (i==j) a->m[i][j]=1.0; else a->m[i][j]=0.0;
+}
+int gl_M4_IsId(M4 *a)
+{
+        int i,j;
+        for(i=0;i<4;i++)
+    for(j=0;j<4;j++) {
+      if (i==j) {
+        if (a->m[i][j] != 1.0) return 0;
+      } else if (a->m[i][j] != 0.0) return 0;
+    }
+  return 1;
+}
+void gl_M4_Mul(M4 *c,M4 *a,M4 *b)
+{
+  int i,j,k;
+  float s;
+  for(i=0;i<4;i++)
+    for(j=0;j<4;j++) {
+      s=0.0;
+      for(k=0;k<4;k++) s+=a->m[i][k]*b->m[k][j];
+      c->m[i][j]=s;
+    }
+}
+/* c=c*a */
+void gl_M4_MulLeft(M4 *c,M4 *b)
+{
+  int i,j,k;
+  float s;
+  M4 a;
+  /*memcpy(&a, c, 16*sizeof(float));
+  */
+  a=*c;
+  for(i=0;i<4;i++)
+    for(j=0;j<4;j++) {
+      s=0.0;
+      for(k=0;k<4;k++) s+=a.m[i][k]*b->m[k][j];
+      c->m[i][j]=s;
+    }
+}
+void gl_M4_Move(M4 *a,M4 *b)
+{
+        memcpy(a,b,sizeof(M4));
+}
+void gl_MoveV3(V3 *a,V3 *b)
+{
+        memcpy(a,b,sizeof(V3));
+}
+void gl_MulM4V3(V3 *a,M4 *b,V3 *c)
+{
+         a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3];
+         a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3];
+         a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3];
+}
+void gl_MulM3V3(V3 *a,M4 *b,V3 *c)
+{
+         a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z;
+         a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z;
+         a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z;
+}
+void gl_M4_MulV4(V4 *a,M4 *b,V4 *c)
+{
+         a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3]*c->W;
+         a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3]*c->W;
+         a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3]*c->W;
+         a->W=b->m[3][0]*c->X+b->m[3][1]*c->Y+b->m[3][2]*c->Z+b->m[3][3]*c->W;
+}
+/* transposition of a 4x4 matrix */
+void gl_M4_Transpose(M4 *a,M4 *b)
+{
+  a->m[0][0]=b->m[0][0];
+  a->m[0][1]=b->m[1][0];
+  a->m[0][2]=b->m[2][0];
+  a->m[0][3]=b->m[3][0];
+  a->m[1][0]=b->m[0][1];
+  a->m[1][1]=b->m[1][1];
+  a->m[1][2]=b->m[2][1];
+  a->m[1][3]=b->m[3][1];
+  a->m[2][0]=b->m[0][2];
+  a->m[2][1]=b->m[1][2];
+  a->m[2][2]=b->m[2][2];
+  a->m[2][3]=b->m[3][2];
+  a->m[3][0]=b->m[0][3];
+  a->m[3][1]=b->m[1][3];
+  a->m[3][2]=b->m[2][3];
+  a->m[3][3]=b->m[3][3];
+}
+/* inversion of an orthogonal matrix of type Y=M.X+P */
+void gl_M4_InvOrtho(M4 *a,M4 b)
+{
+        int i,j;
+        float s;
+        for(i=0;i<3;i++)
+        for(j=0;j<3;j++) a->m[i][j]=b.m[j][i];
+        a->m[3][0]=0.0; a->m[3][1]=0.0; a->m[3][2]=0.0; a->m[3][3]=1.0;
+        for(i=0;i<3;i++) {
+                s=0;
+                for(j=0;j<3;j++) s-=b.m[j][i]*b.m[j][3];
+                a->m[i][3]=s;
+        }
+}
+/* Inversion of a general nxn matrix.
+   Note : m is destroyed */
+int Matrix_Inv(float *r,float *m,int n)
+{
+         int i,j,k,l;
+         float max,tmp,t;
+         /* identitée dans r */
+         for(i=0;i<n*n;i++) r[i]=0;
+         for(i=0;i<n;i++) r[i*n+i]=1;
+         for(j=0;j<n;j++) {
+                        /* recherche du nombre de plus grand module sur la colonne j */
+                        max=m[j*n+j];
+                        k=j;
+                        for(i=j+1;i<n;i++)
+                                if (fabs(m[i*n+j])>fabs(max)) {
+                                         k=i;
+                                         max=m[i*n+j];
+                                }
+      /* non intersible matrix */
+      if (max==0) return 1;
+                        /* permutation des lignes j et k */
+                        if (k!=j) {
+                                 for(i=0;i<n;i++) {
+                                                tmp=m[j*n+i];
+                                                m[j*n+i]=m[k*n+i];
+                                                m[k*n+i]=tmp;
+                                                tmp=r[j*n+i];
+                                                r[j*n+i]=r[k*n+i];
+                                                r[k*n+i]=tmp;
+                                 }
+                        }
+                        /* multiplication de la ligne j par 1/max */
+                        max=1/max;
+                        for(i=0;i<n;i++) {
+                                 m[j*n+i]*=max;
+                                 r[j*n+i]*=max;
+                        }
+                        for(l=0;l<n;l++) if (l!=j) {
+                                 t=m[l*n+j];
+                                 for(i=0;i<n;i++) {
+                                                m[l*n+i]-=m[j*n+i]*t;
+                                                r[l*n+i]-=r[j*n+i]*t;
+                                 }
+                        }
+         }
+         return 0;
+}
+/* inversion of a 4x4 matrix */
+void gl_M4_Inv(M4 *a,M4 *b)
+{
+  M4 tmp;
+  memcpy(&tmp, b, 16*sizeof(float));
+  Matrix_Inv(&a->m[0][0],&tmp.m[0][0],4);
+}
+void gl_M4_Rotate(M4 *a,float t,int u)
+{
+         float s,c;
+         int v,w;
+   if ((v=u+1)>2) v=0;
+         if ((w=v+1)>2) w=0;
+         s=sin(t);
+         c=cos(t);
+         gl_M4_Id(a);
+         a->m[v][v]=c;  a->m[v][w]=-s;
+         a->m[w][v]=s;  a->m[w][w]=c;
+}
+/* inverse of a 3x3 matrix */
+void gl_M3_Inv(M3 *a,M3 *m)
+{
+         float det;
+         det = m->m[0][0]*m->m[1][1]*m->m[2][2]-m->m[0][0]*m->m[1][2]*m->m[2][1]-
+                 m->m[1][0]*m->m[0][1]*m->m[2][2]+m->m[1][0]*m->m[0][2]*m->m[2][1]+
+                 m->m[2][0]*m->m[0][1]*m->m[1][2]-m->m[2][0]*m->m[0][2]*m->m[1][1];
+         a->m[0][0] = (m->m[1][1]*m->m[2][2]-m->m[1][2]*m->m[2][1])/det;
+         a->m[0][1] = -(m->m[0][1]*m->m[2][2]-m->m[0][2]*m->m[2][1])/det;
+         a->m[0][2] = -(-m->m[0][1]*m->m[1][2]+m->m[0][2]*m->m[1][1])/det;
+         a->m[1][0] = -(m->m[1][0]*m->m[2][2]-m->m[1][2]*m->m[2][0])/det;
+         a->m[1][1] = (m->m[0][0]*m->m[2][2]-m->m[0][2]*m->m[2][0])/det;
+         a->m[1][2] = -(m->m[0][0]*m->m[1][2]-m->m[0][2]*m->m[1][0])/det;
+         a->m[2][0] = (m->m[1][0]*m->m[2][1]-m->m[1][1]*m->m[2][0])/det;
+         a->m[2][1] = -(m->m[0][0]*m->m[2][1]-m->m[0][1]*m->m[2][0])/det;
+         a->m[2][2] = (m->m[0][0]*m->m[1][1]-m->m[0][1]*m->m[1][0])/det;
+}
+/* vector arithmetic */
+int gl_V3_Norm(V3 *a)
+{
+        float n;
+        n=sqrt(a->X*a->X+a->Y*a->Y+a->Z*a->Z);
+        if (n==0) return 1;
+        a->X/=n;
+        a->Y/=n;
+        a->Z/=n;
+        return 0;
+}
+V3 gl_V3_New(float x,float y,float z)
+{
+         V3 a;
+         a.X=x;
+         a.Y=y;
+         a.Z=z;
+         return a;
+}
+V4 gl_V4_New(float x,float y,float z,float w)
+{
+  V4 a;
+  a.X=x;
+  a.Y=y;
+  a.Z=z;
+  a.W=w;
+  return a;
+}

 /programs/develop/libraries/TinyGL/src/zmath.h
 ,0 → 1,56
+#ifndef __ZMATH__
+#define __ZMATH__
+/*for menuetlibc*/
+#define pow powf
+/* Matrix & Vertex */
+typedef struct {
+        float m[4][4];
+} M4;
+typedef struct {
+        float m[3][3];
+} M3;
+typedef struct {
+         float m[3][4];
+} M34;
+#define X v[0]
+#define Y v[1]
+#define Z v[2]
+#define W v[3]
+typedef struct {
+         float v[3];
+} V3;
+typedef struct {
+         float v[4];
+} V4;
+void gl_M4_Id(M4 *a);
+int gl_M4_IsId(M4 *a);
+void gl_M4_Move(M4 *a,M4 *b);
+void gl_MoveV3(V3 *a,V3 *b);
+void gl_MulM4V3(V3 *a,M4 *b,V3 *c);
+void gl_MulM3V3(V3 *a,M4 *b,V3 *c);
+void gl_M4_MulV4(V4 * a,M4 *b,V4 * c);
+void gl_M4_InvOrtho(M4 *a,M4 b);
+void gl_M4_Inv(M4 *a,M4 *b);
+void gl_M4_Mul(M4 *c,M4 *a,M4 *b);
+void gl_M4_MulLeft(M4 *c,M4 *a);
+void gl_M4_Transpose(M4 *a,M4 *b);
+void gl_M4_Rotate(M4 *c,float t,int u);
+int  gl_V3_Norm(V3 *a);
+V3 gl_V3_New(float x,float y,float z);
+V4 gl_V4_New(float x,float y,float z,float w);
+int gl_Matrix_Inv(float *r,float *m,int n);
+#endif  /*__ZMATH__*/

 /programs/develop/libraries/TinyGL/src/ztriangle.c
 ,0 → 1,394
+#include <stdlib.h>
+#include "zbuffer.h"
+#define ZCMP(z,zpix) ((z) >= (zpix))
+void ZB_fillTriangleFlat(ZBuffer *zb,
+                         ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+#if TGL_FEATURE_RENDER_BITS == 24
+    unsigned char colorR, colorG, colorB;
+#else
+    int color;
+#endif
+#define INTERP_Z
+#if TGL_FEATURE_RENDER_BITS == 24
+#define DRAW_INIT()                             \
+{                                               \
+  colorR=p2->r>>8; \
+  colorG=p2->g>>8; \
+  colorB=p2->b>>8; \
+}
+#define PUT_PIXEL(_a)           \
+{                                               \
+    zz=z >> ZB_POINT_Z_FRAC_BITS;               \
+    if (ZCMP(zz,pz[_a])) {                              \
+      pp[3 * _a]=colorR;\
+      pp[3 * _a + 1]=colorG;\
+      pp[3 * _a + 2]=colorB;\
+      pz[_a]=zz;                                \
+    }\
+    z+=dzdx;                                    \
+}
+#else
+#define DRAW_INIT()                             \
+{                                               \
+  color=RGB_TO_PIXEL(p2->r,p2->g,p2->b);        \
+}
+#define PUT_PIXEL(_a)                           \
+{                                               \
+    zz=z >> ZB_POINT_Z_FRAC_BITS;               \
+    if (ZCMP(zz,pz[_a])) {                              \
+      pp[_a]=color;                             \
+      pz[_a]=zz;                                \
+    }                                           \
+    z+=dzdx;                                    \
+}
+#endif /* TGL_FEATURE_RENDER_BITS == 24 */
+#include "ztriangle.h"
+}
+/*
+ * Smooth filled triangle.
+ * The code below is very tricky :)
+ */
+void ZB_fillTriangleSmooth(ZBuffer *zb,
+                           ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+#if TGL_FEATURE_RENDER_BITS == 16
+        int _drgbdx;
+#endif
+#define INTERP_Z
+#define INTERP_RGB
+#define SAR_RND_TO_ZERO(v,n) (v / (1<<n))
+#if TGL_FEATURE_RENDER_BITS == 24
+#define DRAW_INIT()                             \
+{                                               \
+}
+#define PUT_PIXEL(_a)                           \
+{                                               \
+    zz=z >> ZB_POINT_Z_FRAC_BITS;               \
+    if (ZCMP(zz,pz[_a])) {                              \
+      pp[3 * _a]=or1 >> 8;\
+      pp[3 * _a + 1]=og1 >> 8;\
+      pp[3 * _a + 2]=ob1 >> 8;\
+      pz[_a]=zz;                                \
+    }\
+    z+=dzdx;                                    \
+    og1+=dgdx;                                  \
+    or1+=drdx;                                  \
+    ob1+=dbdx;                                  \
+}
+#elif TGL_FEATURE_RENDER_BITS == 16
+#define DRAW_INIT()                             \
+{                                               \
+  _drgbdx=(SAR_RND_TO_ZERO(drdx,6) << 22) & 0xFFC00000;         \
+  _drgbdx|=SAR_RND_TO_ZERO(dgdx,5) & 0x000007FF;                \
+  _drgbdx|=(SAR_RND_TO_ZERO(dbdx,7) << 12) & 0x001FF000;        \
+}
+#define PUT_PIXEL(_a)                           \
+{                                               \
+    zz=z >> ZB_POINT_Z_FRAC_BITS;               \
+    if (ZCMP(zz,pz[_a])) {                              \
+      tmp=rgb & 0xF81F07E0;                     \
+      pp[_a]=tmp | (tmp >> 16);                 \
+      pz[_a]=zz;                                \
+    }                                           \
+    z+=dzdx;                                    \
+    rgb=(rgb+drgbdx) & ( ~ 0x00200800);         \
+}
+#define DRAW_LINE()                                                        \
+{                                                                          \
+  register unsigned short *pz;                                     \
+  register PIXEL *pp;                                      \
+  register unsigned int tmp,z,zz,rgb,drgbdx;                               \
+  register int n;                                                          \
+  n=(x2 >> 16) - x1;                                                       \
+  pp=pp1+x1;                                                               \
+  pz=pz1+x1;                                                               \
+  z=z1;                                                                    \
+  rgb=(r1 << 16) & 0xFFC00000;                                             \
+  rgb|=(g1 >> 5) & 0x000007FF;                                             \
+  rgb|=(b1 << 5) & 0x001FF000;                                             \
+  drgbdx=_drgbdx;                                                          \
+  while (n>=3) {                                                           \
+    PUT_PIXEL(0);                                                          \
+    PUT_PIXEL(1);                                                          \
+    PUT_PIXEL(2);                                                          \
+    PUT_PIXEL(3);                                                          \
+    pz+=4;                                                                 \
+    pp+=4;                                                                 \
+    n-=4;                                                                  \
+  }                                                                        \
+  while (n>=0) {                                                           \
+    PUT_PIXEL(0);                                                          \
+    pz+=1;                                                                 \
+    pp+=1;                                                                 \
+    n-=1;                                                                  \
+  }                                                                        \
+}
+#else
+#define DRAW_INIT()                             \
+{                                               \
+}
+#define PUT_PIXEL(_a)                           \
+{                                               \
+    zz=z >> ZB_POINT_Z_FRAC_BITS;               \
+    if (ZCMP(zz,pz[_a])) {                              \
+      pp[_a] = RGB_TO_PIXEL(or1, og1, ob1);\
+      pz[_a]=zz;                                \
+    }\
+    z+=dzdx;                                    \
+    og1+=dgdx;                                  \
+    or1+=drdx;                                  \
+    ob1+=dbdx;                                  \
+}
+#endif /* TGL_FEATURE_RENDER_BITS */
+#include "ztriangle.h"
+}
+void ZB_setTexture(ZBuffer *zb,PIXEL *texture)
+{
+    zb->current_texture=texture;
+}
+void ZB_fillTriangleMapping(ZBuffer *zb,
+                            ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+    PIXEL *texture;
+#define INTERP_Z
+#define INTERP_ST
+#define DRAW_INIT()                             \
+{                                               \
+  texture=zb->current_texture;                  \
+}
+#if TGL_FEATURE_RENDER_BITS == 24
+#define PUT_PIXEL(_a)                           \
+{                                               \
+   unsigned char *ptr;\
+   zz=z >> ZB_POINT_Z_FRAC_BITS;                \
+     if (ZCMP(zz,pz[_a])) {                             \
+       ptr = texture + (((t & 0x3FC00000) | s) >> 14) * 3; \
+       pp[3 * _a]= ptr[0];\
+       pp[3 * _a + 1]= ptr[1];\
+       pp[3 * _a + 2]= ptr[2];\
+       pz[_a]=zz;                               \
+    }                                           \
+    z+=dzdx;                                    \
+    s+=dsdx;                                    \
+    t+=dtdx;                                    \
+}
+#else
+#define PUT_PIXEL(_a)                           \
+{                                               \
+   zz=z >> ZB_POINT_Z_FRAC_BITS;                \
+     if (ZCMP(zz,pz[_a])) {                             \
+       pp[_a]=texture[((t & 0x3FC00000) | s) >> 14];    \
+       pz[_a]=zz;                               \
+    }                                           \
+    z+=dzdx;                                    \
+    s+=dsdx;                                    \
+    t+=dtdx;                                    \
+}
+#endif
+#include "ztriangle.h"
+}
+/*
+ * Texture mapping with perspective correction.
+ * We use the gradient method to make less divisions.
+ * TODO: pipeline the division
+ */
+#if 1
+void ZB_fillTriangleMappingPerspective(ZBuffer *zb,
+                            ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+    PIXEL *texture;
+    float fdzdx,fndzdx,ndszdx,ndtzdx;
+#define INTERP_Z
+#define INTERP_STZ
+#define NB_INTERP 8
+#define DRAW_INIT()                             \
+{                                               \
+  texture=zb->current_texture;\
+  fdzdx=(float)dzdx;\
+  fndzdx=NB_INTERP * fdzdx;\
+  ndszdx=NB_INTERP * dszdx;\
+  ndtzdx=NB_INTERP * dtzdx;\
+}
+#if TGL_FEATURE_RENDER_BITS == 24
+#define PUT_PIXEL(_a)                           \
+{                                               \
+   unsigned char *ptr;\
+   zz=z >> ZB_POINT_Z_FRAC_BITS;                \
+     if (ZCMP(zz,pz[_a])) {                             \
+       ptr = texture + (((t & 0x3FC00000) | (s & 0x003FC000)) >> 14) * 3;\
+       pp[3 * _a]= ptr[0];\
+       pp[3 * _a + 1]= ptr[1];\
+       pp[3 * _a + 2]= ptr[2];\
+       pz[_a]=zz;                               \
+    }                                           \
+    z+=dzdx;                                    \
+    s+=dsdx;                                    \
+    t+=dtdx;                                    \
+}
+#else
+#define PUT_PIXEL(_a)                           \
+{                                               \
+   zz=z >> ZB_POINT_Z_FRAC_BITS;                \
+     if (ZCMP(zz,pz[_a])) {                             \
+       pp[_a]=*(PIXEL *)((char *)texture+ \
+               (((t & 0x3FC00000) | (s & 0x003FC000)) >> (17 - PSZSH)));\
+       pz[_a]=zz;                               \
+    }                                           \
+    z+=dzdx;                                    \
+    s+=dsdx;                                    \
+    t+=dtdx;                                    \
+}
+#endif
+#define DRAW_LINE()                             \
+{                                               \
+  register unsigned short *pz;          \
+  register PIXEL *pp;           \
+  register unsigned int s,t,z,zz;       \
+  register int n,dsdx,dtdx;             \
+  float sz,tz,fz,zinv; \
+  n=(x2>>16)-x1;                             \
+  fz=(float)z1;\
+  zinv=1.0 / fz;\
+  pp=(PIXEL *)((char *)pp1 + x1 * PSZB); \
+  pz=pz1+x1;                                    \
+  z=z1;                                         \
+  sz=sz1;\
+  tz=tz1;\
+  while (n>=(NB_INTERP-1)) {                                               \
+    {\
+      float ss,tt;\
+      ss=(sz * zinv);\
+      tt=(tz * zinv);\
+      s=(int) ss;\
+      t=(int) tt;\
+      dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\
+      dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\
+      fz+=fndzdx;\
+      zinv=1.0 / fz;\
+    }\
+    PUT_PIXEL(0);                                                          \
+    PUT_PIXEL(1);                                                          \
+    PUT_PIXEL(2);                                                          \
+    PUT_PIXEL(3);                                                          \
+    PUT_PIXEL(4);                                                          \
+    PUT_PIXEL(5);                                                          \
+    PUT_PIXEL(6);                                                          \
+    PUT_PIXEL(7);                                                          \
+    pz+=NB_INTERP;                                                         \
+    pp=(PIXEL *)((char *)pp + NB_INTERP * PSZB);\
+    n-=NB_INTERP;                                                          \
+    sz+=ndszdx;\
+    tz+=ndtzdx;\
+  }                                                                        \
+    {\
+      float ss,tt;\
+      ss=(sz * zinv);\
+      tt=(tz * zinv);\
+      s=(int) ss;\
+      t=(int) tt;\
+      dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\
+      dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\
+    }\
+  while (n>=0) {                                                           \
+    PUT_PIXEL(0);                                                          \
+    pz+=1;                                                                 \
+    pp=(PIXEL *)((char *)pp + PSZB);\
+    n-=1;                                                                  \
+  }                                                                        \
+}
+#include "ztriangle.h"
+}
+#endif
+#if 0
+/* slow but exact version (only there for reference, incorrect for 24
+   bits) */
+void ZB_fillTriangleMappingPerspective(ZBuffer *zb,
+                            ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+    PIXEL *texture;
+#define INTERP_Z
+#define INTERP_STZ
+#define DRAW_INIT()                             \
+{                                               \
+  texture=zb->current_texture;                  \
+}
+#define PUT_PIXEL(_a)                           \
+{                                               \
+   float zinv; \
+   int s,t; \
+   zz=z >> ZB_POINT_Z_FRAC_BITS;                \
+     if (ZCMP(zz,pz[_a])) {                             \
+       zinv= 1.0 / (float) z; \
+       s= (int) (sz * zinv); \
+       t= (int) (tz * zinv); \
+       pp[_a]=texture[((t & 0x3FC00000) | s) >> 14];    \
+       pz[_a]=zz;                               \
+    }                                           \
+    z+=dzdx;                                    \
+    sz+=dszdx;                                  \
+    tz+=dtzdx;                                  \
+}
+#include "ztriangle.h"
+}
+#endif

 /programs/develop/libraries/TinyGL/src/ztriangle.h
 ,0 → 1,363
+/*
+ * We draw a triangle with various interpolations
+ */
+{
+  ZBufferPoint *t,*pr1,*pr2,*l1,*l2;
+  float fdx1, fdx2, fdy1, fdy2, fz, d1, d2;
+  unsigned short *pz1;
+  PIXEL *pp1;
+  int part,update_left,update_right;
+  int nb_lines,dx1,dy1,tmp,dx2,dy2;
+  int error,derror;
+  int x1,dxdy_min,dxdy_max;
+/* warning: x2 is multiplied by 2^16 */
+  int x2,dx2dy2;
+#ifdef INTERP_Z
+  int z1,dzdx,dzdy,dzdl_min,dzdl_max;
+#endif
+#ifdef INTERP_RGB
+  int r1,drdx,drdy,drdl_min,drdl_max;
+  int g1,dgdx,dgdy,dgdl_min,dgdl_max;
+  int b1,dbdx,dbdy,dbdl_min,dbdl_max;
+#endif
+#ifdef INTERP_ST
+  int s1,dsdx,dsdy,dsdl_min,dsdl_max;
+  int t1,dtdx,dtdy,dtdl_min,dtdl_max;
+#endif
+#ifdef INTERP_STZ
+  float sz1,dszdx,dszdy,dszdl_min,dszdl_max;
+  float tz1,dtzdx,dtzdy,dtzdl_min,dtzdl_max;
+#endif
+  /* we sort the vertex with increasing y */
+  if (p1->y < p0->y) {
+    t = p0;
+    p0 = p1;
+    p1 = t;
+  }
+  if (p2->y < p0->y) {
+    t = p2;
+    p2 = p1;
+    p1 = p0;
+    p0 = t;
+  } else if (p2->y < p1->y) {
+    t = p1;
+    p1 = p2;
+    p2 = t;
+  }
+  /* we compute dXdx and dXdy for all interpolated values */
+  fdx1 = p1->x - p0->x;
+  fdy1 = p1->y - p0->y;
+  fdx2 = p2->x - p0->x;
+  fdy2 = p2->y - p0->y;
+  fz = fdx1 * fdy2 - fdx2 * fdy1;
+  if (fz == 0)
+    return;
+  fz = 1.0 / fz;
+  fdx1 *= fz;
+  fdy1 *= fz;
+  fdx2 *= fz;
+  fdy2 *= fz;
+#ifdef INTERP_Z
+  d1 = p1->z - p0->z;
+  d2 = p2->z - p0->z;
+  dzdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dzdy = (int) (fdx1 * d2 - fdx2 * d1);
+#endif
+#ifdef INTERP_RGB
+  d1 = p1->r - p0->r;
+  d2 = p2->r - p0->r;
+  drdx = (int) (fdy2 * d1 - fdy1 * d2);
+  drdy = (int) (fdx1 * d2 - fdx2 * d1);
+  d1 = p1->g - p0->g;
+  d2 = p2->g - p0->g;
+  dgdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dgdy = (int) (fdx1 * d2 - fdx2 * d1);
+  d1 = p1->b - p0->b;
+  d2 = p2->b - p0->b;
+  dbdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dbdy = (int) (fdx1 * d2 - fdx2 * d1);
+#endif
+#ifdef INTERP_ST
+  d1 = p1->s - p0->s;
+  d2 = p2->s - p0->s;
+  dsdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dsdy = (int) (fdx1 * d2 - fdx2 * d1);
+  d1 = p1->t - p0->t;
+  d2 = p2->t - p0->t;
+  dtdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dtdy = (int) (fdx1 * d2 - fdx2 * d1);
+#endif
+#ifdef INTERP_STZ
+  {
+    float zz;
+    zz=(float) p0->z;
+    p0->sz= (float) p0->s * zz;
+    p0->tz= (float) p0->t * zz;
+    zz=(float) p1->z;
+    p1->sz= (float) p1->s * zz;
+    p1->tz= (float) p1->t * zz;
+    zz=(float) p2->z;
+    p2->sz= (float) p2->s * zz;
+    p2->tz= (float) p2->t * zz;
+    d1 = p1->sz - p0->sz;
+    d2 = p2->sz - p0->sz;
+    dszdx = (fdy2 * d1 - fdy1 * d2);
+    dszdy = (fdx1 * d2 - fdx2 * d1);
+    d1 = p1->tz - p0->tz;
+    d2 = p2->tz - p0->tz;
+    dtzdx = (fdy2 * d1 - fdy1 * d2);
+    dtzdy = (fdx1 * d2 - fdx2 * d1);
+  }
+#endif
+  /* screen coordinates */
+  pp1 = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p0->y);
+  pz1 = zb->zbuf + p0->y * zb->xsize;
+  DRAW_INIT();
+  for(part=0;part<2;part++) {
+    if (part == 0) {
+      if (fz > 0) {
+        update_left=1;
+        update_right=1;
+        l1=p0;
+        l2=p2;
+        pr1=p0;
+        pr2=p1;
+      } else {
+        update_left=1;
+        update_right=1;
+        l1=p0;
+        l2=p1;
+        pr1=p0;
+        pr2=p2;
+      }
+      nb_lines = p1->y - p0->y;
+    } else {
+      /* second part */
+      if (fz > 0) {
+        update_left=0;
+        update_right=1;
+        pr1=p1;
+        pr2=p2;
+      } else {
+        update_left=1;
+        update_right=0;
+        l1=p1;
+        l2=p2;
+      }
+      nb_lines = p2->y - p1->y + 1;
+    }
+    /* compute the values for the left edge */
+    if (update_left) {
+      dy1 = l2->y - l1->y;
+      dx1 = l2->x - l1->x;
+      if (dy1 > 0)
+        tmp = (dx1 << 16) / dy1;
+      else
+        tmp = 0;
+      x1 = l1->x;
+      error = 0;
+      derror = tmp & 0x0000ffff;
+      dxdy_min = tmp >> 16;
+      dxdy_max = dxdy_min + 1;
+#ifdef INTERP_Z
+      z1=l1->z;
+      dzdl_min=(dzdy + dzdx * dxdy_min);
+      dzdl_max=dzdl_min + dzdx;
+#endif
+#ifdef INTERP_RGB
+      r1=l1->r;
+      drdl_min=(drdy + drdx * dxdy_min);
+      drdl_max=drdl_min + drdx;
+      g1=l1->g;
+      dgdl_min=(dgdy + dgdx * dxdy_min);
+      dgdl_max=dgdl_min + dgdx;
+      b1=l1->b;
+      dbdl_min=(dbdy + dbdx * dxdy_min);
+      dbdl_max=dbdl_min + dbdx;
+#endif
+#ifdef INTERP_ST
+      s1=l1->s;
+      dsdl_min=(dsdy + dsdx * dxdy_min);
+      dsdl_max=dsdl_min + dsdx;
+      t1=l1->t;
+      dtdl_min=(dtdy + dtdx * dxdy_min);
+      dtdl_max=dtdl_min + dtdx;
+#endif
+#ifdef INTERP_STZ
+      sz1=l1->sz;
+      dszdl_min=(dszdy + dszdx * dxdy_min);
+      dszdl_max=dszdl_min + dszdx;
+      tz1=l1->tz;
+      dtzdl_min=(dtzdy + dtzdx * dxdy_min);
+      dtzdl_max=dtzdl_min + dtzdx;
+#endif
+    }
+    /* compute values for the right edge */
+    if (update_right) {
+      dx2 = (pr2->x - pr1->x);
+      dy2 = (pr2->y - pr1->y);
+      if (dy2>0)
+        dx2dy2 = ( dx2 << 16) / dy2;
+      else
+        dx2dy2 = 0;
+      x2 = pr1->x << 16;
+    }
+    /* we draw all the scan line of the part */
+    while (nb_lines>0) {
+      nb_lines--;
+#ifndef DRAW_LINE
+      /* generic draw line */
+      {
+          register PIXEL *pp;
+          register int n;
+#ifdef INTERP_Z
+          register unsigned short *pz;
+          register unsigned int z,zz;
+#endif
+#ifdef INTERP_RGB
+          register unsigned int or1,og1,ob1;
+#endif
+#ifdef INTERP_ST
+          register unsigned int s,t;
+#endif
+#ifdef INTERP_STZ
+          float sz,tz;
+#endif
+          n=(x2 >> 16) - x1;
+          pp=(PIXEL *)((char *)pp1 + x1 * PSZB);
+#ifdef INTERP_Z
+          pz=pz1+x1;
+          z=z1;
+#endif
+#ifdef INTERP_RGB
+          or1 = r1;
+          og1 = g1;
+          ob1 = b1;
+#endif
+#ifdef INTERP_ST
+          s=s1;
+          t=t1;
+#endif
+#ifdef INTERP_STZ
+          sz=sz1;
+          tz=tz1;
+#endif
+          while (n>=3) {
+              PUT_PIXEL(0);
+              PUT_PIXEL(1);
+              PUT_PIXEL(2);
+              PUT_PIXEL(3);
+#ifdef INTERP_Z
+              pz+=4;
+#endif
+              pp=(PIXEL *)((char *)pp + 4 * PSZB);
+              n-=4;
+          }
+          while (n>=0) {
+              PUT_PIXEL(0);
+#ifdef INTERP_Z
+              pz+=1;
+#endif
+              pp=(PIXEL *)((char *)pp + PSZB);
+              n-=1;
+          }
+      }
+#else
+      DRAW_LINE();
+#endif
+      /* left edge */
+      error+=derror;
+      if (error > 0) {
+        error-=0x10000;
+        x1+=dxdy_max;
+#ifdef INTERP_Z
+        z1+=dzdl_max;
+#endif
+#ifdef INTERP_RGB
+        r1+=drdl_max;
+        g1+=dgdl_max;
+        b1+=dbdl_max;
+#endif
+#ifdef INTERP_ST
+        s1+=dsdl_max;
+        t1+=dtdl_max;
+#endif
+#ifdef INTERP_STZ
+        sz1+=dszdl_max;
+        tz1+=dtzdl_max;
+#endif
+      } else {
+        x1+=dxdy_min;
+#ifdef INTERP_Z
+        z1+=dzdl_min;
+#endif
+#ifdef INTERP_RGB
+        r1+=drdl_min;
+        g1+=dgdl_min;
+        b1+=dbdl_min;
+#endif
+#ifdef INTERP_ST
+        s1+=dsdl_min;
+        t1+=dtdl_min;
+#endif
+#ifdef INTERP_STZ
+        sz1+=dszdl_min;
+        tz1+=dtzdl_min;
+#endif
+      }
+      /* right edge */
+      x2+=dx2dy2;
+      /* screen coordinates */
+      pp1=(PIXEL *)((char *)pp1 + zb->linesize);
+      pz1+=zb->xsize;
+    }
+  }
+}
+#undef INTERP_Z
+#undef INTERP_RGB
+#undef INTERP_ST
+#undef INTERP_STZ
+#undef DRAW_INIT
+#undef DRAW_LINE
+#undef PUT_PIXEL

/programs/develop/libraries/base64/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_GCC") ~= "" then return end
tup.rule("base64.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "base64.obj")

/programs/develop/libraries/box_lib/asm/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.foreach_rule({"ctrldemo.asm", "editbox_ex.asm"}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B")

/programs/develop/libraries/box_lib/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("box_lib.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "box_lib.obj")

/programs/develop/libraries/buf2d/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("buf2d.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "buf2d.obj")

/programs/develop/libraries/buf2d/trunk/examples/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B")

/programs/develop/libraries/charset/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("charset.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "charset.obj")

/programs/develop/libraries/console/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("console.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "console.obj")

/programs/develop/libraries/console/examples/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B")

/programs/develop/libraries/crypt_des/example/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("crypt_files.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "crypt_files")

/programs/develop/libraries/crypt_des/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("crypt_des.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "crypt_des.obj")

/programs/develop/libraries/exif/examples/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("viev_exif.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "viev_exif")

/programs/develop/libraries/exif/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("exif.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "exif.obj")

/programs/develop/libraries/fontslib/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("font_.asm", "fasm %f %o", "font01.ksf")
tup.rule("fonts_lib.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "fonts_lib.obj")

/programs/develop/libraries/gblib/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_GCC") ~= "" then return end
tup.rule("gblib.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "gblib.obj")

/programs/develop/libraries/gblib/example/Tupfile.lua
0,0 → 1,7
if tup.getconfig("NO_FASM") ~= "" or tup.getconfig("NO_GCC") ~= "" then return end
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../.." or tup.getconfig("HELPERDIR")
tup.include(HELPERDIR .. "/use_gcc.lua")
LDFLAGS = LDFLAGS .. " -T kolibri.ld"
tup.append_table(OBJS, tup.rule("asm_code.asm", "fasm %f %o", "asm_code.o"))
compile_gcc{"example.c", "system/kolibri.c", "system/stdlib.c", "system/string.c"}
link_gcc("example")

 /programs/develop/libraries/gblib/example/gblib.h
 ,11 → 1,13
+#pragma pack(push, 1)
 typedef struct
 {
-int  w       __attribute__((packed));
-int  h       __attribute__((packed));
-char *bmp    __attribute__((packed));
-char *alpha  __attribute__((packed));
-} GB_BMP     __attribute__((packed));
+int  w;
+int  h;
+char *bmp;
+char *alpha;
+} GB_BMP;
+#pragma pack(pop)
 void (* __stdcall gb_pixel_set)(GB_BMP *b, int x, int y, unsigned c);

 /programs/develop/libraries/gblib/example/kolibri.ld
 ,4 → 17,8
     *(.bss)
    }
    Memory = . ;
+   /DISCARD/ : {
+    *(.comment)
+    *(.drectve)
 }
+}

 /programs/develop/libraries/gblib/example/system/kolibri.h
 ,38 → 1,40
 #define NULL ((void*)0)
+#pragma pack(push, 1)
 typedef struct
 {
-unsigned        p00 __attribute__((packed));
-unsigned        p04 __attribute__((packed));
-unsigned        p08 __attribute__((packed));
-unsigned        p12 __attribute__((packed));
-unsigned        p16 __attribute__((packed));
-char            p20 __attribute__((packed));
-char            *p21 __attribute__((packed));
-} kol_struct70 __attribute__((packed));
+unsigned        p00;
+unsigned        p04;
+unsigned        p08;
+unsigned        p12;
+unsigned        p16;
+char            p20;
+char            *p21;
+} kol_struct70;
 typedef struct
 {
-unsigned        p00 __attribute__((packed));
-char            p04 __attribute__((packed));
-char            p05[3] __attribute__((packed));
-unsigned        p08 __attribute__((packed));
-unsigned        p12 __attribute__((packed));
-unsigned        p16 __attribute__((packed));
-unsigned        p20 __attribute__((packed));
-unsigned        p24 __attribute__((packed));
-unsigned        p28 __attribute__((packed));
-unsigned        p32[2] __attribute__((packed));
-unsigned        p40 __attribute__((packed));
-} kol_struct_BDVK __attribute__((packed));
+unsigned        p00;
+char            p04;
+char            p05[3];
+unsigned        p08;
+unsigned        p12;
+unsigned        p16;
+unsigned        p20;
+unsigned        p24;
+unsigned        p28;
+unsigned        p32[2];
+unsigned        p40;
+} kol_struct_BDVK;
 typedef struct
 {
-char    *name __attribute__((packed));
-void    *data __attribute__((packed));
-} kol_struct_import __attribute__((packed));
+char    *name;
+void    *data;
+} kol_struct_import;
+#pragma pack(pop)
 void kol_exit();

/programs/develop/libraries/http/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("http.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "http.obj")

/programs/develop/libraries/http/examples/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B")

/programs/develop/libraries/iconv/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_GCC") ~= "" then return end
tup.rule("iconv.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "iconv.obj")

 /programs/develop/libraries/iconv/iconv.c
 ,5 → 1,7
-#include <string.h>
-#include <stdio.h>
+//#include <string.h>
+//#include <stdio.h>
+typedef unsigned int size_t;
+#define NULL ((void*)0)
 typedef int conv_t;
 typedef unsigned int ucs4_t;

/programs/develop/libraries/libcrash/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("libcrash.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libcrash.obj")
tup.rule("crashtest.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "crashtest")

/programs/develop/libraries/libs-dev/libgfx/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("libgfx.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libgfx.obj")

/programs/develop/libraries/libs-dev/libimg/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("libimg.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libimg.obj")

/programs/develop/libraries/libs-dev/libini/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("libini.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libini.obj")

/programs/develop/libraries/libs-dev/libio/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("libio.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libio.obj")

/programs/develop/libraries/menuetlibc/programs/multiview/test.jpg
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/programs/develop/libraries/menuetlibc/Makefile
11,7 → 11,6
make -C src depend
make -C src
make -C stub
make -C programs

genconfig:
ifdef ON_MINGW
24,5 → 23,4
make -C src clean
make -C linuxtools clean
make -C stub clean
make -C programs clean
$(RM) mkversion$(EXESUFFIX)

/programs/develop/libraries/menuetlibc/Tupfile.lua
0,0 → 1,6
if tup.getconfig("TUP_PLATFORM") == "win32"
-- on win32 '#' is not a special character, but backslash and quotes would be printed as is
then tup.rule('echo #define NEEDS_UNDERSCORES > %o', {"config.h"})
-- on unix '#' should be escaped
else tup.rule('echo "#define NEEDS_UNDERSCORES" > %o', {"config.h"})
end

 /programs/develop/libraries/menuetlibc/include/libm/math.h
 ,7 → 167,7
 extern double j1 __P((double));
 extern double jn __P((int, double));
 extern double lgamma __P((double));
-extern double nan __P((void));
+extern double nan __P((const char*));
 extern double y0 __P((double));
 extern double y1 __P((double));
 extern double yn __P((int, double));
 ,7 → 187,7
 extern double pow10 __P((double));
 extern double pow2 __P((double));
 extern double powi __P((double, int));
-extern void   sincos __P((double *, double *, double));
+extern void   sincos __P((double, double *, double *));
 extern double remainder __P((double, double));
 extern double scalb __P((double, double));
 ,7 → 263,7
 extern float j1f __P((float));
 extern float jnf __P((int, float));
 extern float lgammaf __P((float));
-extern float nanf __P((void));
+extern float nanf __P((const char*));
 extern float y0f __P((float));
 extern float y1f __P((float));
 extern float ynf __P((int, float));

 /programs/develop/libraries/menuetlibc/include/math.h
 ,7 → 74,7
 double  pow10(double _x);
 double  pow2(double _x);
 double  powi(double, int);
-void    sincos(double *, double *, double);
+void    sincos(double, double *, double *);
 /* These are in libm.a (Cygnus).  You must link -lm to get these */
 /* See libm/math.h for comments */
 ,7 → 100,7
 extern double j1(double);
 extern double jn(int, double);
 extern double lgamma(double);
-extern double nan(void);
+extern double nan(const char*);
 extern double y0(double);
 extern double y1(double);
 extern double yn(int, double);
 ,7 → 152,7
 extern float j1f(float);
 extern float jnf(int, float);
 extern float lgammaf(float);
-extern float nanf(void);
+extern float nanf(const char*);
 extern float y0f(float);
 extern float y1f(float);
 extern float ynf(int, float);

 /programs/develop/libraries/menuetlibc/include/scripts/menuetos_app_v01.ld
 ,6 → 5,7
  .text 0x000000 :
  {
   code = . ; _code = . ;
+  *(.A)
   *(.text)
   *(.fixup)
   *(.gnu.warning)
 ,6 → 44,24
  {
   *(.bss)
  }
- end = . ; _end = . ;
+ end = . ; _end = . ; ___memsize = . ;
+  /DISCARD/ :
+  {
+    *(.debug$S)
+    *(.debug$T)
+    *(.debug$F)
+    *(.drectve)
+    *(.note.GNU-stack)
+    *(.eh_frame)
+    *(.comment)
+    *(.debug_abbrev)
+    *(.debug_info)
+    *(.debug_line)
+    *(.debug_frame)
+    *(.debug_loc)
+    *(.debug_pubnames)
+    *(.debug_aranges)
+    *(.debug_ranges)
 }
+}

 /programs/develop/libraries/menuetlibc/include/string.h
 ,8 → 49,8
 #include <sys/movedata.h>
 int     bcmp(const void *_ptr1, const void *_ptr2, int _length);
-void *  bcopy(const void *_a, void *_b, size_t _len);
-void *  bzero(void *ptr, size_t _len);
+void    bcopy(const void *_a, void *_b, size_t _len);
+void    bzero(void *ptr, size_t _len);
 int     ffs(int _mask);
 char *  index(const char *_string, int _c);
 void *  memccpy(void *_to, const void *_from, int c, size_t n);

 /programs/develop/libraries/menuetlibc/src/libc/Tupfile.lua
 ,0 → 1,85
+if tup.getconfig("NO_GCC") ~= "" then return end
+FOLDERS = {
+  "ansi/assert",
+  "ansi/ctype",
+  "ansi/errno",
+  "ansi/locale",
+  "ansi/math",
+  "ansi/setjmp",
+  "ansi/stdio",
+  "ansi/stdlib",
+  "ansi/string",
+  "ansi/time",
+  "ansif",
+  "compat/bsd",
+  "compat/io",
+  "compat/math",
+  "compat/mman",
+  "compat/mntent",
+  "compat/search",
+  "compat/signal",
+  "compat/stdio",
+  "compat/stdlib",
+  "compat/string",
+  "compat/sys/resource",
+  "compat/sys/stat",
+  "compat/sys/vfs",
+  "compat/termios",
+  "compat/time",
+  "compat/unistd",
+  "compat/v1",
+  "crt0",
+  "dos/compat",
+  "dos/dir",
+  "dos/dos",
+  "dos/dos_emu",
+  "dos/errno",
+  "dos/io",
+  "dos/process",
+  "dos/sys/timeb",
+  "fsext",
+  "menuetos",
+  "net",
+  "pc_hw/cpu",
+  "pc_hw/endian",
+  "pc_hw/farptr",
+  "pc_hw/fpu",
+  "pc_hw/hwint",
+  "pc_hw/kb",
+  "pc_hw/mem",
+  "pc_hw/sound",
+  "pc_hw/timer",
+  "posix/dirent",
+  "posix/fcntl",
+  "posix/fnmatch",
+  "posix/glob",
+  "posix/grp",
+-- "posix/regex", -- not compilable
+  "posix/pwd",
+  "posix/setjmp",
+  "posix/signal",
+  "posix/stdio",
+  "posix/sys/stat",
+  "posix/sys/times",
+  "posix/sys/wait",
+  "posix/unistd",
+  "posix/utime",
+  "posix/utsname",
+  "termios",
+}
+CFLAGS="-Os -fno-stack-check -fno-stack-protector -mno-stack-arg-probe -fno-ident -fomit-frame-pointer -fno-asynchronous-unwind-tables -mpreferred-stack-boundary=2"
+OBJS={}
+for i,v in ipairs(FOLDERS) do
+  tup.append_table(OBJS,
+    tup.foreach_rule({v .. "/*.c", extra_inputs = {"../../config.h"}},
+      'kos32-gcc -c -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" ' .. CFLAGS .. " -o %o %f",
+      v .. "/%B.o")
+  )
+  tup.append_table(OBJS,
+    tup.foreach_rule({v .. "/*.s", extra_inputs = {"../../config.h"}},
+      'kos32-cpp -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" %f | kos32-as -o %o',
+      v .. "/%B.o")
+  )
+end
+tup.rule(OBJS, "kos32-ar rcs %o %f", {"../../lib/libc.a", "../../<libc>"})

/programs/develop/libraries/menuetlibc/src/libc/ansi/stdio/fprintf.c
1,5 → 1,6
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
#include <stdio.h>
#include <stdarg.h>
#include <libc/file.h>

int

 /programs/develop/libraries/menuetlibc/src/libc/compat/bsd/bcopy.c
 ,8 → 3,8
 #undef bcopy
-void *
+void
 bcopy(const void *a, void *b, size_t len)
 {
-  return memmove(b, a, len);
+  memmove(b, a, len);
 }

 /programs/develop/libraries/menuetlibc/src/libc/compat/bsd/bzero.c
 ,8 → 3,8
 #undef bzero
-void *
+void
 bzero(void *a, size_t b)
 {
-  return memset(a,0,b);
+  memset(a,0,b);
 }

 /programs/develop/libraries/menuetlibc/src/libc/compat/math/sincos.s
 ,18 → 6,18
 MK_C_SYM(sincos)
-        /* void sincos(double *cosine, double *sine, double x); */
+        /* void sincos(double x, double *sine, double *cosine); */
-        movl    16(%esp), %ecx
+        movl    8(%esp), %ecx
-        movl    4(%esp), %eax           /* Point to cosine. */
-        movl    8(%esp), %edx           /* Point to sine. */
+        movl    16(%esp), %eax          /* Point to cosine. */
+        movl    12(%esp), %edx          /* Point to sine. */
         andl    $0x7FF00000, %ecx       /* Examine exponent of x. */
         cmpl    $0x43E00000, %ecx       /* |x| >= 2^63 */
         jae     bigarg
-        fldl    12(%esp)
+        fldl    4(%esp)
         fsincos
         fstpl   (%eax)                  /* cos */
         fstpl   (%edx)                  /* sin */

/programs/develop/libraries/menuetlibc/src/libcpp/Tupfile.lua
0,0 → 1,6
if tup.getconfig('NO_GCC') ~= "" then return end
CFLAGS = "-Os -fno-stack-check -fno-stack-protector -mno-stack-arg-probe -fno-ident -fomit-frame-pointer -fno-asynchronous-unwind-tables -mpreferred-stack-boundary=2"
OBJS = tup.foreach_rule({"*.cpp", extra_inputs = {"../../config.h"}},
'kos32-gcc -c -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" ' .. CFLAGS .. " -o %o %f",
"%B.o")
tup.rule(OBJS, "kos32-ar rcs %o %f", {"../../lib/libcpp.a", "../../<libcpp>"})

 /programs/develop/libraries/menuetlibc/src/libm/Tupfile.lua
 ,0 → 1,9
+if tup.getconfig('NO_GCC') ~= "" then return end
+CFLAGS="-D_USE_LIBM_MATH_H -Os -fno-stack-check -fno-stack-protector -mno-stack-arg-probe -fno-ident -fomit-frame-pointer -fno-asynchronous-unwind-tables -mpreferred-stack-boundary=2"
+OBJS = tup.foreach_rule({"*.c", extra_inputs = {"../../config.h"}},
+  'kos32-gcc -c -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" ' .. CFLAGS .. ' -o %o %f',
+  "%B.o")
+OBJS += tup.foreach_rule({"*.s", extra_inputs = {"../../config.h"}},
+  'kos32-cpp -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" %f | kos32-as -o %o',
+  "%B.o")
+tup.rule(OBJS, "kos32-ar rcs %o %f", {"../../lib/libm.a", "../../<libm>"})

 /programs/develop/libraries/menuetlibc/src/libm/k_standa.c
 ,6 → 28,8
 #undef fflush
 #endif  /* !defined(_USE_WRITE) */
+inline int fputs(const char* str, FILE* f) { return -1; }
 #ifdef __STDC__
 static const double zero = 0.0; /* used as const */
 #else

/programs/develop/libraries/menuetlibc/stub/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("crt0_coff.asm", "fasm %f %o", "crt0.o")

 /programs/develop/libraries/menuetlibc/stub/crt0_coff.asm
 ,6 → 7,7
 EXTRN ___menuet__app_param_area
 EXTRN ___menuet__app_path_area
 EXTRN ___crt1_startup
+EXTRN ___memsize
 start:
 public ___menuet__app_header
 public ___menuet__memsize
 ,7 → 23,7
 ; dd _edata
  dd 0
 ___menuet__memsize:
- dd 0x400000
+ dd ___memsize
  dd app_stack
  dd ___menuet__app_param_area
  dd ___menuet__app_path_area
 ,5 → 55,6
 end if
 section '.bss' readable writeable
-rd 0x20000
+;rd 0x20000
+rb 0x10000
 app_stack:

/programs/develop/libraries/menuetlibc_example/Tupfile.lua
0,0 → 1,6
if tup.getconfig('NO_GCC') ~= "" then return end
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../.." or tup.getconfig("HELPERDIR")
tup.include(HELPERDIR .. "/use_gcc.lua")
tup.include(HELPERDIR .. "/use_menuetlibc.lua")
compile_gcc{"main.c"}
link_gcc("binclock")

 /programs/develop/libraries/menuetlibc_example/main.c
 ,0 → 1,89
+#include<menuet/os.h>
+#define B_SZ    10
+static char * Title="BinClock";
+static void draw_small_box(int x,int y,int is_on)
+{
+ __menuet__bar(x,y,B_SZ,B_SZ,is_on ? 0xFF0000 : 0x103000);
+}
+static void draw_box_group(int x,int y,int num)
+{
+ int i,j;
+ char buf[2];
+ buf[0]=(num&(1+2+4+8))+'0';
+ buf[1]='\0';
+ for(i=0;i<4;i++)
+ {
+  j=(B_SZ+2)*i;
+  draw_small_box(x,y+((B_SZ+2)*i),num & (1<<(3-i)) ? 1 : 0);
+ }
+ __menuet__bar(x,y+((B_SZ+2)*4),B_SZ,B_SZ,0x800000);
+ __menuet__write_text(x+2,y+((B_SZ+2)*4)+3,0xFFFFFF,buf,1);
+}
+static void draw_bcd_num(int x,int y,int num)
+{
+ int v1,v2;
+ v1=(num>>4)&(1+2+4+8);
+ v2=num & (1+2+4+8);
+ draw_box_group(x,y,v1);
+ draw_box_group(x+B_SZ+2,y,v2);
+}
+static void draw_hms(int x,int y)
+{
+ __u32 t;
+ int h,m,s;
+ t=__menuet__getsystemclock();
+ s=(t & 0x00FF0000)>>16;
+ m=(t & 0x0000FF00)>>8;
+ h=(t & 0x000000FF);
+ draw_bcd_num(x,y,h);
+ x+=((B_SZ+2)<<1)+2;
+ draw_bcd_num(x,y,m);
+ x+=((B_SZ+2)<<1)+2;
+ draw_bcd_num(x,y,s);
+}
+static void draw_h(void)
+{
+ draw_hms(22,28);
+}
+static void paint(void)
+{
+ __menuet__window_redraw(1);
+ __menuet__define_window(100,100,40+((B_SZ+2)*6)+4,30+((B_SZ+2)*4)+16,0x03000080,0x800000FF,0x000080);
+ __menuet__write_text(3,3,0xFFFFFF,Title,strlen(Title));
+ __menuet__bar(20,26,((B_SZ+2)*6)+4+2,4+((B_SZ+1)*4)+2,0);
+ draw_h();
+ __menuet__window_redraw(2);
+}
+void main(void)
+{
+ int i;
+ paint();
+ for(;;)
+ {
+  __menuet__delay100(20);
+  i=__menuet__check_for_event();
+  draw_h();
+  switch(i)
+  {
+   case 1:
+    paint();
+    continue;
+   case 2:
+    __menuet__getkey();
+    continue;
+   case 3:
+    if(__menuet__get_button_id()==1) __menuet__sys_exit();
+    continue;
+  }
+ }
+}

/programs/develop/libraries/menuetlibc_example/Makefile
0,0 → 1,3
OUTFILE = mbinclk
OBJS = main.o
include $(MENUETDEV)/makefiles/Makefile_for_program

/programs/develop/libraries/msgbox/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("msgbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "msgbox.obj")

/programs/develop/libraries/network/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("network.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "network.obj")

/programs/develop/libraries/network/examples/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("nslookup.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "nslookup")

/programs/develop/libraries/pixlib/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_GCC") ~= "" then return end
tup.rule("pixlib.c", "kos32-gcc -march=pentium-mmx -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "pixlib.obj")

/programs/develop/libraries/proc_lib/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("proc_lib.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "proc_lib.obj")

/programs/develop/libraries/qs/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_GCC") ~= "" then return end
tup.rule("qs.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "qs.obj")

/programs/develop/libraries/sorter/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("sort.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "sort.obj")

/programs/develop/libraries/ufmod/Fasm/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"mini.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "mini")

 /programs/develop/libraries/ufmod/Tupfile.lua
 ,0 → 1,32
+if tup.getconfig("NO_FASM") ~= "" then return end
+-- Select mixing rate: 22050, 44100 or 48000 (22.05 KHz, 44.1 KHz or 48 KHz)
+UF_FREQ="48000"
+-- Set volume ramping mode (interpolation): NONE, WEAK or STRONG
+UF_RAMP="STRONG"
+-- Set build mode: NORMAL, UNSAFE or AC97SND
+UF_MODE="NORMAL"
+if tup.getconfig("TUP_PLATFORM") == "win32"
+then tup.rule(
+  "echo UF_FREQ  equ $(UF_FREQ)  > %o && " ..
+  "echo UF_RAMP  equ $(UF_RAMP) >> %o && " ..
+  "echo UF_MODE  equ $(UF_MODE) >> %o && " ..
+  "echo DEBUG    equ 0          >> %o && " ..
+  "echo NOLINKER equ 0          >> %o && " ..
+  "echo include 'eff.inc'       >> %o && " ..
+  "echo include 'fasm.asm'      >> %o",
+  {"tmp.asm"})
+else tup.rule(
+  "echo UF_FREQ  equ $(UF_FREQ)  > %o && " ..
+  "echo UF_RAMP  equ $(UF_RAMP) >> %o && " ..
+  "echo UF_MODE  equ $(UF_MODE) >> %o && " ..
+  "echo DEBUG    equ 0          >> %o && " ..
+  "echo NOLINKER equ 0          >> %o && " ..
+  "echo include \"'eff.inc'\"   >> %o && " ..
+  "echo include \"'fasm.asm'\"  >> %o",
+  {"tmp.asm"})
+end
+tup.rule("tmp.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "ufmod.obj")

/programs/develop/libraries/utils/trunk/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("utils.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "utils.obj")

/programs/develop/libraries/wword/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("wword.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "wword.obj")

/programs/develop/mstate/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_NASM") ~= "" then return end
tup.rule("mstate.asm", "nasm -t -f bin -o %o %f " .. tup.getconfig("KPACK_CMD"), "mstate")

 /programs/develop/mstate/mstate.asm
 ,11 → 77,11
 MENUET01                          db 'MENUET01'
 version                           dd 1
 program.start                     dd START
-program.end                       dd END
-program.memory                    dd END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE
-program.stack                     dd END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE
-program.params                    dd END + PATH_SIZE
-program.path                      dd END
+program.end                       dd _END
+program.memory                    dd _END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE
+program.stack                     dd _END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE
+program.params                    dd _END + PATH_SIZE
+program.path                      dd _END
 ; ---------------------------------------------------------------------------- ;
 mouse_body_color                  dd MOUSE_BODY_COLOR
 mouse_left_button_color           dd MOUSE_LEFT_BUTTON_COLOR
 ,4 → 243,4
         int    64
 ; ---------------------------------------------------------------------------- ;
 align 4
-END:
+_END:

/programs/develop/mtdbg/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("mtdbg.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "mtdbg")

/programs/develop/param/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"param.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "param")

/programs/develop/scancode/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"scancode.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "scancode")

 /programs/develop/scc/CC1.ASM
 ,0 → 1,5066
+_nogo: TIMES 1 DD 0
+_noloc: TIMES 1 DD 0
+_opindex: TIMES 1 DD 0
+_opsize: TIMES 1 DD 0
+_swactive: TIMES 1 DD 0
+_swdefaul: TIMES 1 DD 0
+_swnext DD 0
+_swend DD 0
+_stage DD 0
+_wq DD 0
+_argcs: TIMES 1 DD 0
+_argvs DD 0
+_wqptr DD 0
+_litptr: TIMES 1 DD 0
+_macptr: TIMES 1 DD 0
+_pptr: TIMES 1 DD 0
+_ch: TIMES 1 DD 0
+_nch: TIMES 1 DD 0
+_declared: TIMES 1 DD 0
+_iflevel: TIMES 1 DD 0
+_skipleve: TIMES 1 DD 0
+_nxtlab: TIMES 1 DD 0
+_litlab: TIMES 1 DD 0
+_csp: TIMES 1 DD 0
+_argstk: TIMES 1 DD 0
+_argtop: TIMES 1 DD 0
+_ncmp: TIMES 1 DD 0
+_errflag: TIMES 1 DD 0
+_eof: TIMES 1 DD 0
+_output: TIMES 1 DD 0
+_files: TIMES 1 DD 0
+_filearg DD 0
+_input DD -1
+_input2 DD -1
+_usexpr DD 1
+_ccode DD 1
+_snext DD 0
+_stail DD 0
+_slast DD 0
+_listfp: TIMES 1 DD 0
+_lastst: TIMES 1 DD 0
+_oldseg: TIMES 1 DD 0
+_optimize: TIMES 1 DB 0
+_alarm: TIMES 1 DB 0
+_monitor: TIMES 1 DB 0
+_pause: TIMES 1 DB 0
+_symtab DD 0
+_litq DD 0
+_macn DD 0
+_macq DD 0
+_pline DD 0
+_mline DD 0
+_line DD 0
+_lptr DD 0
+_glbptr DD 0
+_locptr DD 0
+_quote DB 34
+ TIMES 1 DB 0
+_cptr DD 0
+_cptr2 DD 0
+_cptr3 DD 0
+_msname: TIMES 9 DB 0
+_ssname: TIMES 9 DB 0
+_op DD 57,73,3,20,55,43,22,47,35,7
+ DD 6,1,69,52,16,49
+_op2 DD 57,73,3,20,55,44,23,48,36,7
+ DD 6,1,69,53,17,50
+_main:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_1_1+0
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,32
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_1+47
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,32
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_1+95
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,32
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_argcs],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_argvs],EAX
+MOV EAX,360
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_swnext],EAX
+MOV EAX,[_swnext]
+MOV EBX,1424
+ADD EAX,EBX
+MOV DWORD [_swend],EAX
+MOV EAX,200
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_stage],EAX
+MOV EAX,30
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_wq],EAX
+MOV DWORD [_wqptr],EAX
+MOV EAX,3000
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_litq],EAX
+MOV EAX,3300
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_macn],EAX
+MOV EAX,2100
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_macq],EAX
+MOV EAX,128
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_pline],EAX
+MOV EAX,128
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_mline],EAX
+MOV EAX,[_stage]
+MOV EBX,6400
+ADD EAX,EBX
+MOV DWORD [_slast],EAX
+MOV EAX,4400
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _OS_callo
+ADD ESP,8
+MOV DWORD [_symtab],EAX
+MOV EAX,[_symtab]
+MOV DWORD [_locptr],EAX
+MOV EAX,[_symtab]
+MOV EBX,400
+ADD EAX,EBX
+MOV DWORD [_glbptr],EAX
+XOR CL,CL
+CALL _ask
+XOR CL,CL
+CALL _openfile
+XOR CL,CL
+CALL _preproce
+XOR CL,CL
+CALL _header
+XOR CL,CL
+CALL _setcodes
+XOR CL,CL
+CALL _parse
+XOR CL,CL
+CALL _trailer
+MOV EAX,[_output]
+PUSH EAX
+MOV CL,1
+CALL _OS_fclos
+ADD ESP,4
+POP EBP
+RET
+_1_1 DB 83,109,97,108,108,32,67,32,51,56
+ DB 54,47,78,84,44,32,86,101,114,115
+ DB 105,111,110,32,51,46,49,44,32,82
+ DB 101,118,105,115,105,111,110,32,76,101
+ DB 118,101,108,32,49,10,0,67,111,112
+ DB 121,114,105,103,104,116,32,49,57,56
+ DB 50,44,32,49,57,56,51,44,32,49
+ DB 57,56,53,44,32,49,57,56,56,32
+ DB 74,46,32,69,46,32,72,101,110,100
+ DB 114,105,120,10,0,67,111,112,121,114
+ DB 105,103,104,116,32,49,57,57,56,32
+ DB 32,72,32,84,32,87,97,108,104,101
+ DB 105,109,10,10,0
+_parse:
+PUSH EBP
+MOV EBP,ESP
+_1_3:
+MOV EAX,[_eof]
+OR EAX,EAX
+JE _1_5
+JMP _1_4
+_1_5:
+MOV EAX,_1_2+0
+PUSH EAX
+MOV EAX,6
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_7
+JMP _1_6
+_1_7:
+MOV EAX,3
+PUSH EAX
+MOV CL,1
+CALL _dodeclar
+ADD ESP,4
+JMP _1_8
+_1_6:
+MOV EAX,2
+PUSH EAX
+MOV CL,1
+CALL _dodeclar
+ADD ESP,4
+OR EAX,EAX
+JNE _1_10
+JMP _1_9
+_1_10:
+JMP _1_11
+_1_9:
+MOV EAX,_1_2+7
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_13
+JMP _1_12
+_1_13:
+XOR CL,CL
+CALL _doasm
+JMP _1_14
+_1_12:
+MOV EAX,_1_2+12
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_16
+JMP _1_15
+_1_16:
+XOR CL,CL
+CALL _doinclud
+JMP _1_17
+_1_15:
+MOV EAX,_1_2+21
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_19
+JMP _1_18
+_1_19:
+XOR CL,CL
+CALL _dodefine
+JMP _1_20
+_1_18:
+XOR CL,CL
+CALL _dofuncti
+_1_20:
+_1_17:
+_1_14:
+_1_11:
+_1_8:
+XOR CL,CL
+CALL _blanks
+JMP _1_3
+_1_4:
+POP EBP
+RET
+_1_2 DB 101,120,116,101,114,110,0,35,97,115
+ DB 109,0,35,105,110,99,108,117,100,101
+ DB 0,35,100,101,102,105,110,101,0
+_dodeclar:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_1_21+0
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_23
+JMP _1_22
+_1_23:
+MOV EAX,4
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _declglb
+ADD ESP,8
+JMP _1_24
+_1_22:
+MOV EAX,_1_21+5
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_26
+JMP _1_25
+_1_26:
+MOV EAX,_1_21+14
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_28
+JMP _1_27
+_1_28:
+MOV EAX,5
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _declglb
+ADD ESP,8
+JMP _1_29
+_1_27:
+MOV EAX,_1_21+19
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+MOV EAX,17
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _declglb
+ADD ESP,8
+_1_29:
+JMP _1_30
+_1_25:
+MOV EAX,_1_21+23
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JE _1_34
+JMP _1_32
+_1_34:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JE _1_35
+JMP _1_32
+_1_35:
+XOR EAX,EAX
+JMP _1_33
+_1_32:
+MOV EAX,1
+_1_33:
+OR EAX,EAX
+JNE _1_36
+JMP _1_31
+_1_36:
+MOV EAX,16
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _declglb
+ADD ESP,8
+JMP _1_37
+_1_31:
+XOR EAX,EAX
+POP EBP
+RET
+_1_37:
+_1_30:
+_1_24:
+XOR CL,CL
+CALL _ns
+MOV EAX,1
+POP EBP
+RET
+_1_21 DB 99,104,97,114,0,117,110,115,105,103
+ DB 110,101,100,0,99,104,97,114,0,105
+ DB 110,116,0,105,110,116,0
+_declglb:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+_1_39:
+XOR CL,CL
+CALL _endst
+OR EAX,EAX
+JNE _1_42
+JMP _1_41
+_1_42:
+MOV ESP,EBP
+POP EBP
+RET
+_1_41:
+MOV EAX,_1_38+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_44
+JMP _1_43
+_1_44:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX,3
+MOV [EBX],EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+JMP _1_45
+_1_43:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+_1_45:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JE _1_47
+JMP _1_46
+_1_47:
+XOR CL,CL
+CALL _illname
+_1_46:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _findglb
+ADD ESP,4
+OR EAX,EAX
+JNE _1_49
+JMP _1_48
+_1_49:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _multidef
+ADD ESP,4
+_1_48:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JNE _1_51
+JMP _1_50
+_1_51:
+MOV EAX,_1_38+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_53
+JMP _1_52
+_1_53:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX,4
+MOV [EBX],EAX
+MOV EAX,_1_38+4
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+JMP _1_54
+_1_52:
+MOV EAX,_1_38+6
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_56
+JMP _1_55
+_1_56:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX,2
+MOV [EBX],EAX
+LEA EAX,[EBP-8]
+PUSH EAX
+XOR CL,CL
+CALL _needsub
+POP EBX
+MOV [EBX],EAX
+_1_55:
+_1_54:
+_1_50:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _1_58
+JMP _1_57
+_1_58:
+MOV EAX,_ssname
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _external
+ADD ESP,12
+JMP _1_59
+_1_57:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,4
+CALL __ne
+OR EAX,EAX
+JNE _1_61
+JMP _1_60
+_1_61:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _initials
+ADD ESP,12
+_1_60:
+_1_59:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _1_63
+JMP _1_62
+_1_63:
+MOV EAX,_ssname
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,_glbptr
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,7
+CALL _addsym
+ADD ESP,28
+JMP _1_64
+_1_62:
+MOV EAX,_ssname
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+POP EBX
+IMUL EBX
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,_glbptr
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,7
+CALL _addsym
+ADD ESP,28
+_1_64:
+MOV EAX,_1_38+8
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_66
+JMP _1_65
+_1_66:
+MOV ESP,EBP
+POP EBP
+RET
+_1_65:
+JMP _1_39
+_1_40:
+MOV ESP,EBP
+POP EBP
+RET
+_1_38 DB 42,0,40,0,41,0,91,0,44,0
+_initials:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+XOR EAX,EAX
+MOV DWORD [_litptr],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _1_69
+JMP _1_68
+_1_69:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX,-1
+MOV [EBX],EAX
+_1_68:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+MOV EAX,_1_67+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_71
+JMP _1_70
+_1_71:
+MOV EAX,_1_67+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_73
+JMP _1_72
+_1_73:
+_1_74:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _1_76
+JMP _1_75
+_1_76:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+PUSH EAX
+MOV CL,3
+CALL _init
+ADD ESP,12
+MOV EAX,_1_67+4
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_78
+JMP _1_77
+_1_78:
+JMP _1_75
+_1_77:
+JMP _1_74
+_1_75:
+MOV EAX,_1_67+6
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+JMP _1_79
+_1_72:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+PUSH EAX
+MOV CL,3
+CALL _init
+ADD ESP,12
+_1_79:
+_1_70:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,-1
+CALL __eq
+OR EAX,EAX
+JNE _1_83
+JMP _1_81
+_1_83:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,-1
+CALL __eq
+OR EAX,EAX
+JNE _1_84
+JMP _1_81
+_1_84:
+MOV EAX,1
+JMP _1_82
+_1_81:
+XOR EAX,EAX
+_1_82:
+OR EAX,EAX
+JNE _1_85
+JMP _1_80
+_1_85:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _1_87
+JMP _1_86
+_1_87:
+MOV EAX,_1_67+8
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_86:
+XOR EAX,EAX
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX,4
+MOV [EBX],EAX
+PUSH EAX
+MOV CL,2
+CALL _stowlit
+ADD ESP,8
+_1_80:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _public
+ADD ESP,4
+MOV EAX,[_litptr]
+OR EAX,EAX
+JG _1_89
+JMP _1_88
+_1_89:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _dumplits
+ADD ESP,4
+JMP _1_90
+_1_88:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JG _1_92
+JMP _1_91
+_1_92:
+MOV EAX,58
+PUSH EAX
+MOV EAX,[_output]
+PUSH EAX
+MOV CL,2
+CALL _OS_fputc
+ADD ESP,8
+_1_91:
+_1_90:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _dumpzero
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_1_67 DB 61,0,123,0,44,0,125,0,110,101
+ DB 101,100,32,97,114,114,97,121,32,115
+ DB 105,122,101,0
+_init:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV CL,1
+CALL _string
+ADD ESP,4
+OR EAX,EAX
+JNE _1_95
+JMP _1_94
+_1_95:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JE _1_99
+JMP _1_97
+_1_99:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __ne
+OR EAX,EAX
+JE _1_100
+JMP _1_97
+_1_100:
+XOR EAX,EAX
+JMP _1_98
+_1_97:
+MOV EAX,1
+_1_98:
+OR EAX,EAX
+JNE _1_101
+JMP _1_96
+_1_101:
+MOV EAX,_1_93+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_96:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_litptr]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _1_103
+JMP _1_102
+_1_103:
+XOR CL,CL
+CALL _point
+_1_102:
+JMP _1_104
+_1_94:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV CL,1
+CALL _constexp
+ADD ESP,4
+OR EAX,EAX
+JNE _1_106
+JMP _1_105
+_1_106:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _1_108
+JMP _1_107
+_1_108:
+MOV EAX,_1_93+42
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_107:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _stowlit
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+MOV [EBX],EAX
+_1_105:
+_1_104:
+MOV ESP,EBP
+POP EBP
+RET
+_1_93 DB 109,117,115,116,32,97,115,115,105,103
+ DB 110,32,116,111,32,99,104,97,114,32
+ DB 112,111,105,110,116,101,114,32,111,114
+ DB 32,99,104,97,114,32,97,114,114,97
+ DB 121,0,99,97,110,110,111,116,32,97
+ DB 115,115,105,103,110,32,116,111,32,112
+ DB 111,105,110,116,101,114,0
+_needsub:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+MOV EAX,_1_109+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_111
+JMP _1_110
+_1_111:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_1_110:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV CL,1
+CALL _constexp
+ADD ESP,4
+OR EAX,EAX
+JE _1_113
+JMP _1_112
+_1_113:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+_1_112:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JL _1_115
+JMP _1_114
+_1_115:
+MOV EAX,_1_109+2
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+NEG EAX
+POP EBX
+MOV [EBX],EAX
+_1_114:
+MOV EAX,_1_109+24
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_1_109 DB 93,0,110,101,103,97,116,105,118,101
+ DB 32,115,105,122,101,32,105,108,108,101
+ DB 103,97,108,0,93,0
+_doinclud:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-36
+XOR CL,CL
+CALL _blanks
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,34
+CALL __eq
+OR EAX,EAX
+JE _1_120
+JMP _1_118
+_1_120:
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,60
+CALL __eq
+OR EAX,EAX
+JE _1_121
+JMP _1_118
+_1_121:
+XOR EAX,EAX
+JMP _1_119
+_1_118:
+MOV EAX,1
+_1_119:
+OR EAX,EAX
+JNE _1_122
+JMP _1_117
+_1_122:
+MOV EAX,[_lptr]
+INC EAX
+MOV DWORD [_lptr],EAX
+_1_117:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_1_123:
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _1_127
+JMP _1_125
+_1_127:
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,34
+CALL __ne
+OR EAX,EAX
+JNE _1_128
+JMP _1_125
+_1_128:
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,62
+CALL __ne
+OR EAX,EAX
+JNE _1_129
+JMP _1_125
+_1_129:
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,10
+CALL __ne
+OR EAX,EAX
+JNE _1_130
+JMP _1_125
+_1_130:
+MOV EAX,1
+JMP _1_126
+_1_125:
+XOR EAX,EAX
+_1_126:
+OR EAX,EAX
+JNE _1_131
+JMP _1_124
+_1_131:
+LEA EAX,[EBP-36]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+JMP _1_123
+_1_124:
+LEA EAX,[EBP-36]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+LEA EAX,[EBP-36]
+PUSH EAX
+MOV EAX,_1_116+0
+PUSH EAX
+MOV CL,2
+CALL _OS_fopen
+ADD ESP,8
+MOV DWORD [_input2],EAX
+OR EAX,EAX
+JE _1_133
+JMP _1_132
+_1_133:
+MOV EAX,-1
+MOV DWORD [_input2],EAX
+MOV EAX,_1_116+2
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_132:
+XOR CL,CL
+CALL _kill
+MOV ESP,EBP
+POP EBP
+RET
+_1_116 DB 114,0,111,112,101,110,32,102,97,105
+ DB 108,117,114,101,32,111,110,32,105,110
+ DB 99,108,117,100,101,32,102,105,108,101
+ DB 0
+_dodefine:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+MOV EAX,_msname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JE _1_136
+JMP _1_135
+_1_136:
+XOR CL,CL
+CALL _illname
+XOR CL,CL
+CALL _kill
+MOV ESP,EBP
+POP EBP
+RET
+_1_135:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV EAX,_msname
+PUSH EAX
+MOV EAX,[_macn]
+PUSH EAX
+MOV EAX,11
+PUSH EAX
+MOV EAX,[_macn]
+MOV EBX,3300
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,300
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,6
+CALL _search
+ADD ESP,24
+OR EAX,EAX
+JE _1_138
+JMP _1_137
+_1_138:
+MOV EAX,[_cptr]
+MOV DWORD [_cptr2],EAX
+OR EAX,EAX
+JNE _1_140
+JMP _1_139
+_1_140:
+_1_141:
+MOV EAX,[_cptr2]
+INC EAX
+MOV DWORD [_cptr2],EAX
+DEC EAX
+PUSH EAX
+MOV EAX,_msname
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+OR EAX,EAX
+JNE _1_143
+JMP _1_142
+_1_143:
+JMP _1_141
+_1_142:
+JMP _1_144
+_1_139:
+MOV EAX,_1_134+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+MOV ESP,EBP
+POP EBP
+RET
+_1_144:
+_1_137:
+MOV EAX,[_macptr]
+PUSH EAX
+MOV EAX,[_cptr]
+MOV EBX,9
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,2
+PUSH EAX
+MOV CL,3
+CALL _putint
+ADD ESP,12
+_1_145:
+XOR CL,CL
+CALL _white
+OR EAX,EAX
+JNE _1_147
+JMP _1_146
+_1_147:
+XOR CL,CL
+CALL _gch
+JMP _1_145
+_1_146:
+_1_148:
+XOR CL,CL
+CALL _gch
+PUSH EAX
+MOV CL,1
+CALL _putmac
+ADD ESP,4
+OR EAX,EAX
+JNE _1_150
+JMP _1_149
+_1_150:
+JMP _1_148
+_1_149:
+MOV EAX,[_macptr]
+MOV EBX,EAX
+MOV EAX,2099
+CALL __ge
+OR EAX,EAX
+JNE _1_152
+JMP _1_151
+_1_152:
+MOV EAX,_1_134+22
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+MOV EAX,7
+PUSH EAX
+MOV CL,1
+CALL _OS_exit
+ADD ESP,4
+_1_151:
+MOV ESP,EBP
+POP EBP
+RET
+_1_134 DB 109,97,99,114,111,32,110,97,109,101
+ DB 32,116,97,98,108,101,32,102,117,108
+ DB 108,0,109,97,99,114,111,32,115,116
+ DB 114,105,110,103,32,113,117,101,117,101
+ DB 32,102,117,108,108,0
+_putmac:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_macq]
+PUSH EAX
+MOV EAX,[_macptr]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+MOV EAX,[_macptr]
+MOV EBX,EAX
+MOV EAX,2099
+CALL __lt
+OR EAX,EAX
+JNE _1_155
+JMP _1_154
+_1_155:
+MOV EAX,[_macptr]
+INC EAX
+MOV DWORD [_macptr],EAX
+_1_154:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBP
+RET
+_dofuncti:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+XOR EAX,EAX
+MOV DWORD [_litptr],EAX
+MOV DWORD [_lastst],EAX
+MOV DWORD [_noloc],EAX
+MOV DWORD [_nogo],EAX
+XOR CL,CL
+CALL _getlabel
+MOV DWORD [_litlab],EAX
+MOV EAX,[_symtab]
+MOV DWORD [_locptr],EAX
+MOV EAX,_1_156+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_158
+JMP _1_157
+_1_158:
+XOR CL,CL
+CALL _blanks
+_1_157:
+MOVSX EAX,BYTE [_monitor]
+OR EAX,EAX
+JNE _1_160
+JMP _1_159
+_1_160:
+MOV EAX,[_line]
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _lout
+ADD ESP,8
+_1_159:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JE _1_162
+JMP _1_161
+_1_162:
+MOV EAX,_1_156+5
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR EAX,EAX
+MOV DWORD [_errflag],EAX
+XOR CL,CL
+CALL _kill
+MOV ESP,EBP
+POP EBP
+RET
+_1_161:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _findglb
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _1_164
+JMP _1_163
+_1_164:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,2
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,4
+CALL __eq
+OR EAX,EAX
+JNE _1_166
+JMP _1_165
+_1_166:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,2
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,2
+MOV [EBX],AL
+JMP _1_167
+_1_165:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _multidef
+ADD ESP,4
+_1_167:
+JMP _1_168
+_1_163:
+MOV EAX,_ssname
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV EAX,16
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,_glbptr
+PUSH EAX
+MOV EAX,2
+PUSH EAX
+MOV CL,7
+CALL _addsym
+ADD ESP,28
+_1_168:
+MOV EAX,4
+PUSH EAX
+MOV CL,1
+CALL _public
+ADD ESP,4
+XOR EAX,EAX
+MOV DWORD [_argstk],EAX
+MOV EAX,_1_156+37
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_170
+JMP _1_169
+_1_170:
+MOV EAX,_1_156+39
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_169:
+_1_171:
+MOV EAX,_1_156+53
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_173
+JMP _1_172
+_1_173:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JNE _1_175
+JMP _1_174
+_1_175:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _findloc
+ADD ESP,4
+OR EAX,EAX
+JNE _1_177
+JMP _1_176
+_1_177:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _multidef
+ADD ESP,4
+JMP _1_178
+_1_176:
+MOV EAX,_ssname
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,[_argstk]
+PUSH EAX
+MOV EAX,_locptr
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,7
+CALL _addsym
+ADD ESP,28
+MOV EAX,[_argstk]
+MOV EBX,4
+ADD EAX,EBX
+MOV DWORD [_argstk],EAX
+_1_178:
+JMP _1_179
+_1_174:
+MOV EAX,_1_156+55
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR CL,CL
+CALL _skip
+_1_179:
+XOR CL,CL
+CALL _blanks
+MOV EAX,[_lptr]
+PUSH EAX
+MOV EAX,_1_156+77
+PUSH EAX
+MOV CL,2
+CALL _streq
+ADD ESP,8
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JNE _1_183
+JMP _1_181
+_1_183:
+MOV EAX,_1_156+79
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JNE _1_184
+JMP _1_181
+_1_184:
+MOV EAX,1
+JMP _1_182
+_1_181:
+XOR EAX,EAX
+_1_182:
+OR EAX,EAX
+JNE _1_185
+JMP _1_180
+_1_185:
+MOV EAX,_1_156+81
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_180:
+XOR CL,CL
+CALL _endst
+OR EAX,EAX
+JNE _1_187
+JMP _1_186
+_1_187:
+JMP _1_172
+_1_186:
+JMP _1_171
+_1_172:
+XOR EAX,EAX
+MOV DWORD [_csp],EAX
+MOV EAX,[_argstk]
+MOV EBX,4
+ADD EAX,EBX
+MOV DWORD [_argtop],EAX
+_1_188:
+MOV EAX,[_argstk]
+OR EAX,EAX
+JNE _1_190
+JMP _1_189
+_1_190:
+MOV EAX,_1_156+90
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_192
+JMP _1_191
+_1_192:
+MOV EAX,4
+PUSH EAX
+MOV CL,1
+CALL _doargs
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+JMP _1_193
+_1_191:
+MOV EAX,_1_156+95
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_195
+JMP _1_194
+_1_195:
+MOV EAX,16
+PUSH EAX
+MOV CL,1
+CALL _doargs
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+JMP _1_196
+_1_194:
+MOV EAX,_1_156+99
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_198
+JMP _1_197
+_1_198:
+MOV EAX,_1_156+108
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_200
+JMP _1_199
+_1_200:
+MOV EAX,5
+PUSH EAX
+MOV CL,1
+CALL _doargs
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+JMP _1_201
+_1_199:
+MOV EAX,_1_156+113
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+MOV EAX,17
+PUSH EAX
+MOV CL,1
+CALL _doargs
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+_1_201:
+JMP _1_202
+_1_197:
+MOV EAX,_1_156+117
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _1_189
+_1_202:
+_1_196:
+_1_193:
+JMP _1_188
+_1_189:
+MOV EAX,18
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _statemen
+MOV EAX,[_lastst]
+MOV EBX,EAX
+MOV EAX,3
+CALL __ne
+OR EAX,EAX
+JNE _1_206
+JMP _1_204
+_1_206:
+MOV EAX,[_lastst]
+MOV EBX,EAX
+MOV EAX,13
+CALL __ne
+OR EAX,EAX
+JNE _1_207
+JMP _1_204
+_1_207:
+MOV EAX,1
+JMP _1_205
+_1_204:
+XOR EAX,EAX
+_1_205:
+OR EAX,EAX
+JNE _1_208
+JMP _1_203
+_1_208:
+MOV EAX,67
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_1_203:
+MOV EAX,[_litptr]
+OR EAX,EAX
+JNE _1_210
+JMP _1_209
+_1_210:
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _toseg
+ADD ESP,4
+MOV EAX,66
+PUSH EAX
+MOV EAX,[_litlab]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _dumplits
+ADD ESP,4
+_1_209:
+MOV ESP,EBP
+POP EBP
+RET
+_1_156 DB 118,111,105,100,0,105,108,108,101,103
+ DB 97,108,32,102,117,110,99,116,105,111
+ DB 110,32,111,114,32,100,101,99,108,97
+ DB 114,97,116,105,111,110,0,40,0,110
+ DB 111,32,111,112,101,110,32,112,97,114
+ DB 101,110,0,41,0,105,108,108,101,103
+ DB 97,108,32,97,114,103,117,109,101,110
+ DB 116,32,110,97,109,101,0,41,0,44
+ DB 0,110,111,32,99,111,109,109,97,0
+ DB 99,104,97,114,0,105,110,116,0,117
+ DB 110,115,105,103,110,101,100,0,99,104
+ DB 97,114,0,105,110,116,0,119,114,111
+ DB 110,103,32,110,117,109,98,101,114,32
+ DB 111,102,32,97,114,103,117,109,101,110
+ DB 116,115,0
+_doargs:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-16
+_1_212:
+MOV EAX,[_argstk]
+OR EAX,EAX
+JE _1_215
+JMP _1_214
+_1_215:
+MOV ESP,EBP
+POP EBP
+RET
+_1_214:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV CL,4
+CALL _decl
+ADD ESP,16
+OR EAX,EAX
+JNE _1_217
+JMP _1_216
+_1_217:
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _findloc
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _1_219
+JMP _1_218
+_1_219:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],AL
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],AL
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,3
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,3
+CALL _putint
+ADD ESP,12
+MOV EAX,[_argtop]
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,5
+ADD EAX,EBX
+MOV EBX,2
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _getint
+ADD ESP,8
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,5
+ADD EAX,EBX
+MOV EBX,2
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,3
+CALL _putint
+ADD ESP,12
+JMP _1_220
+_1_218:
+MOV EAX,_1_211+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_220:
+_1_216:
+MOV EAX,[_argstk]
+MOV EBX,EAX
+MOV EAX,4
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV DWORD [_argstk],EAX
+XOR CL,CL
+CALL _endst
+OR EAX,EAX
+JNE _1_222
+JMP _1_221
+_1_222:
+MOV ESP,EBP
+POP EBP
+RET
+_1_221:
+MOV EAX,_1_211+16
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_224
+JMP _1_223
+_1_224:
+MOV EAX,_1_211+18
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_223:
+JMP _1_212
+_1_213:
+MOV ESP,EBP
+POP EBP
+RET
+_1_211 DB 110,111,116,32,97,110,32,97,114,103
+ DB 117,109,101,110,116,0,44,0,110,111
+ DB 32,99,111,109,109,97,0
+_decl:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-12
+MOV EAX,_1_225+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_227
+JMP _1_226
+_1_227:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+JMP _1_228
+_1_226:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_1_228:
+MOV EAX,_1_225+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_230
+JMP _1_229
+_1_230:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,4
+MOV [EBX],EAX
+JMP _1_231
+_1_229:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+POP EBX
+MOV [EBX],EAX
+_1_231:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JE _1_233
+JMP _1_232
+_1_233:
+XOR CL,CL
+CALL _illname
+_1_232:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _1_237
+JMP _1_235
+_1_237:
+MOV EAX,_1_225+4
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_238
+JMP _1_235
+_1_238:
+MOV EAX,1
+JMP _1_236
+_1_235:
+XOR EAX,EAX
+_1_236:
+OR EAX,EAX
+JNE _1_239
+JMP _1_234
+_1_239:
+_1_234:
+MOV EAX,_1_225+6
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_241
+JMP _1_240
+_1_241:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+CALL __lneg
+OR EAX,EAX
+JE _1_245
+JMP _1_243
+_1_245:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __ne
+OR EAX,EAX
+JE _1_246
+JMP _1_243
+_1_246:
+XOR EAX,EAX
+JMP _1_244
+_1_243:
+MOV EAX,1
+_1_244:
+OR EAX,EAX
+JNE _1_247
+JMP _1_242
+_1_247:
+MOV EAX,_1_225+8
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_242:
+MOV EAX,_1_225+21
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+JMP _1_248
+_1_240:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JNE _1_252
+JMP _1_250
+_1_252:
+MOV EAX,_1_225+23
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_253
+JMP _1_250
+_1_253:
+MOV EAX,1
+JMP _1_251
+_1_250:
+XOR EAX,EAX
+_1_251:
+OR EAX,EAX
+JNE _1_254
+JMP _1_249
+_1_254:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR CL,CL
+CALL _needsub
+POP EBX
+IMUL EBX
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JE _1_256
+JMP _1_255
+_1_256:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _1_258
+JMP _1_257
+_1_258:
+MOV EAX,_1_225+25
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_257:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,4
+MOV [EBX],EAX
+_1_255:
+_1_249:
+_1_248:
+LEA EAX,[EBP-12]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,4
+XCHG EAX,EBX
+CDQ
+IDIV EBX
+MOV EAX,EDX
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _1_260
+JMP _1_259
+_1_260:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+_1_259:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_1_225 DB 40,0,42,0,41,0,40,0,116,114
+ DB 121,32,40,42,46,46,46,41,40,41
+ DB 0,41,0,91,0,110,101,101,100,32
+ DB 97,114,114,97,121,32,115,105,122,101
+ DB 0
+_statemen:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_ch]
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JNE _1_265
+JMP _1_263
+_1_265:
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _1_266
+JMP _1_263
+_1_266:
+MOV EAX,1
+JMP _1_264
+_1_263:
+XOR EAX,EAX
+_1_264:
+OR EAX,EAX
+JNE _1_267
+JMP _1_262
+_1_267:
+POP EBP
+RET
+_1_262:
+MOV EAX,_1_261+0
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_270
+JMP _1_269
+_1_270:
+MOV EAX,4
+PUSH EAX
+MOV CL,1
+CALL _declloc
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+JMP _1_271
+_1_269:
+MOV EAX,_1_261+5
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_273
+JMP _1_272
+_1_273:
+MOV EAX,16
+PUSH EAX
+MOV CL,1
+CALL _declloc
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+JMP _1_274
+_1_272:
+MOV EAX,_1_261+9
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_276
+JMP _1_275
+_1_276:
+MOV EAX,_1_261+18
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_278
+JMP _1_277
+_1_278:
+MOV EAX,5
+PUSH EAX
+MOV CL,1
+CALL _declloc
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+JMP _1_279
+_1_277:
+MOV EAX,_1_261+23
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+MOV EAX,17
+PUSH EAX
+MOV CL,1
+CALL _declloc
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+_1_279:
+JMP _1_280
+_1_275:
+MOV EAX,[_declared]
+OR EAX,EAX
+JGE _1_282
+JMP _1_281
+_1_282:
+MOV EAX,[_ncmp]
+MOV EBX,EAX
+MOV EAX,1
+CALL __gt
+OR EAX,EAX
+JNE _1_284
+JMP _1_283
+_1_284:
+MOV EAX,[_declared]
+MOV DWORD [_nogo],EAX
+_1_283:
+MOV EAX,2
+PUSH EAX
+MOV EAX,[_csp]
+PUSH EAX
+MOV EAX,[_declared]
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,-1
+MOV DWORD [_declared],EAX
+_1_281:
+MOV EAX,_1_261+27
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_286
+JMP _1_285
+_1_286:
+XOR CL,CL
+CALL _compound
+JMP _1_287
+_1_285:
+MOV EAX,_1_261+29
+PUSH EAX
+MOV EAX,2
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_289
+JMP _1_288
+_1_289:
+XOR CL,CL
+CALL _doif
+MOV EAX,1
+MOV DWORD [_lastst],EAX
+JMP _1_290
+_1_288:
+MOV EAX,_1_261+32
+PUSH EAX
+MOV EAX,5
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_292
+JMP _1_291
+_1_292:
+XOR CL,CL
+CALL _dowhile
+MOV EAX,2
+MOV DWORD [_lastst],EAX
+JMP _1_293
+_1_291:
+MOV EAX,_1_261+38
+PUSH EAX
+MOV EAX,2
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_295
+JMP _1_294
+_1_295:
+XOR CL,CL
+CALL _dodo
+MOV EAX,8
+MOV DWORD [_lastst],EAX
+JMP _1_296
+_1_294:
+MOV EAX,_1_261+41
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_298
+JMP _1_297
+_1_298:
+XOR CL,CL
+CALL _dofor
+MOV EAX,9
+MOV DWORD [_lastst],EAX
+JMP _1_299
+_1_297:
+MOV EAX,_1_261+45
+PUSH EAX
+MOV EAX,6
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_301
+JMP _1_300
+_1_301:
+XOR CL,CL
+CALL _doswitch
+MOV EAX,10
+MOV DWORD [_lastst],EAX
+JMP _1_302
+_1_300:
+MOV EAX,_1_261+52
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_304
+JMP _1_303
+_1_304:
+XOR CL,CL
+CALL _docase
+MOV EAX,11
+MOV DWORD [_lastst],EAX
+JMP _1_305
+_1_303:
+MOV EAX,_1_261+57
+PUSH EAX
+MOV EAX,7
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_307
+JMP _1_306
+_1_307:
+XOR CL,CL
+CALL _dodefaul
+MOV EAX,12
+MOV DWORD [_lastst],EAX
+JMP _1_308
+_1_306:
+MOV EAX,_1_261+65
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_310
+JMP _1_309
+_1_310:
+XOR CL,CL
+CALL _dogoto
+MOV EAX,13
+MOV DWORD [_lastst],EAX
+JMP _1_311
+_1_309:
+XOR CL,CL
+CALL _dolabel
+OR EAX,EAX
+JNE _1_313
+JMP _1_312
+_1_313:
+MOV EAX,14
+MOV DWORD [_lastst],EAX
+JMP _1_314
+_1_312:
+MOV EAX,_1_261+70
+PUSH EAX
+MOV EAX,6
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_316
+JMP _1_315
+_1_316:
+XOR CL,CL
+CALL _doreturn
+XOR CL,CL
+CALL _ns
+MOV EAX,3
+MOV DWORD [_lastst],EAX
+JMP _1_317
+_1_315:
+MOV EAX,_1_261+77
+PUSH EAX
+MOV EAX,5
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_319
+JMP _1_318
+_1_319:
+XOR CL,CL
+CALL _dobreak
+XOR CL,CL
+CALL _ns
+MOV EAX,4
+MOV DWORD [_lastst],EAX
+JMP _1_320
+_1_318:
+MOV EAX,_1_261+83
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _1_322
+JMP _1_321
+_1_322:
+XOR CL,CL
+CALL _docont
+XOR CL,CL
+CALL _ns
+MOV EAX,5
+MOV DWORD [_lastst],EAX
+JMP _1_323
+_1_321:
+MOV EAX,_1_261+92
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_325
+JMP _1_324
+_1_325:
+XOR EAX,EAX
+MOV DWORD [_errflag],EAX
+JMP _1_326
+_1_324:
+MOV EAX,_1_261+94
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_328
+JMP _1_327
+_1_328:
+XOR CL,CL
+CALL _doasm
+MOV EAX,6
+MOV DWORD [_lastst],EAX
+JMP _1_329
+_1_327:
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _doexpr
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+MOV EAX,7
+MOV DWORD [_lastst],EAX
+_1_329:
+_1_326:
+_1_323:
+_1_320:
+_1_317:
+_1_314:
+_1_311:
+_1_308:
+_1_305:
+_1_302:
+_1_299:
+_1_296:
+_1_293:
+_1_290:
+_1_287:
+_1_280:
+_1_274:
+_1_271:
+_1_268:
+MOV EAX,[_lastst]
+POP EBP
+RET
+_1_261 DB 99,104,97,114,0,105,110,116,0,117
+ DB 110,115,105,103,110,101,100,0,99,104
+ DB 97,114,0,105,110,116,0,123,0,105
+ DB 102,0,119,104,105,108,101,0,100,111
+ DB 0,102,111,114,0,115,119,105,116,99
+ DB 104,0,99,97,115,101,0,100,101,102
+ DB 97,117,108,116,0,103,111,116,111,0
+ DB 114,101,116,117,114,110,0,98,114,101
+ DB 97,107,0,99,111,110,116,105,110,117
+ DB 101,0,59,0,35,97,115,109,0
+_declloc:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+MOV EAX,[_swactive]
+OR EAX,EAX
+JNE _1_332
+JMP _1_331
+_1_332:
+MOV EAX,_1_330+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_331:
+MOV EAX,[_noloc]
+OR EAX,EAX
+JNE _1_334
+JMP _1_333
+_1_334:
+MOV EAX,_1_330+22
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_333:
+MOV EAX,[_declared]
+OR EAX,EAX
+JL _1_336
+JMP _1_335
+_1_336:
+MOV EAX,_1_330+44
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_335:
+_1_337:
+XOR CL,CL
+CALL _endst
+OR EAX,EAX
+JNE _1_340
+JMP _1_339
+_1_340:
+MOV ESP,EBP
+POP EBP
+RET
+_1_339:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,2
+PUSH EAX
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV CL,4
+CALL _decl
+ADD ESP,16
+MOV EAX,[_declared]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV DWORD [_declared],EAX
+MOV EAX,_ssname
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_csp]
+PUSH EAX
+MOV EAX,[_declared]
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+PUSH EAX
+MOV EAX,_locptr
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,7
+CALL _addsym
+ADD ESP,28
+MOV EAX,_1_330+72
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_342
+JMP _1_341
+_1_342:
+MOV ESP,EBP
+POP EBP
+RET
+_1_341:
+JMP _1_337
+_1_338:
+MOV ESP,EBP
+POP EBP
+RET
+_1_330 DB 110,111,116,32,97,108,108,111,119,101
+ DB 100,32,105,110,32,115,119,105,116,99
+ DB 104,0,110,111,116,32,97,108,108,111
+ DB 119,101,100,32,119,105,116,104,32,103
+ DB 111,116,111,0,109,117,115,116,32,100
+ DB 101,99,108,97,114,101,32,102,105,114
+ DB 115,116,32,105,110,32,98,108,111,99
+ DB 107,0,44,0
+_compound:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_csp]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV EAX,[_locptr]
+POP EBX
+MOV [EBX],EAX
+XOR EAX,EAX
+MOV DWORD [_declared],EAX
+MOV EAX,[_ncmp]
+INC EAX
+MOV DWORD [_ncmp],EAX
+_1_344:
+MOV EAX,_1_343+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_346
+JMP _1_345
+_1_346:
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _1_348
+JMP _1_347
+_1_348:
+MOV EAX,_1_343+2
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _1_345
+JMP _1_349
+_1_347:
+XOR CL,CL
+CALL _statemen
+_1_349:
+JMP _1_344
+_1_345:
+MOV EAX,[_ncmp]
+DEC EAX
+MOV DWORD [_ncmp],EAX
+OR EAX,EAX
+JNE _1_353
+JMP _1_351
+_1_353:
+MOV EAX,[_lastst]
+MOV EBX,EAX
+MOV EAX,3
+CALL __ne
+OR EAX,EAX
+JNE _1_354
+JMP _1_351
+_1_354:
+MOV EAX,[_lastst]
+MOV EBX,EAX
+MOV EAX,13
+CALL __ne
+OR EAX,EAX
+JNE _1_355
+JMP _1_351
+_1_355:
+MOV EAX,1
+JMP _1_352
+_1_351:
+XOR EAX,EAX
+_1_352:
+OR EAX,EAX
+JNE _1_356
+JMP _1_350
+_1_356:
+MOV EAX,2
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_1_350:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_cptr],EAX
+_1_357:
+MOV EAX,[_cptr]
+PUSH EAX
+MOV EAX,[_locptr]
+POP EBX
+CALL __ult
+OR EAX,EAX
+JNE _1_359
+JMP _1_358
+_1_359:
+MOV EAX,[_cptr]
+PUSH EAX
+MOV CL,1
+CALL _nextsym
+ADD ESP,4
+MOV DWORD [_cptr2],EAX
+MOV EAX,[_cptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JE _1_361
+JMP _1_360
+_1_361:
+_1_362:
+MOV EAX,[_cptr]
+PUSH EAX
+MOV EAX,[_cptr2]
+POP EBX
+CALL __ult
+OR EAX,EAX
+JNE _1_364
+JMP _1_363
+_1_364:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+PUSH EAX
+MOV EAX,[_cptr]
+INC EAX
+MOV DWORD [_cptr],EAX
+DEC EAX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+JMP _1_362
+_1_363:
+JMP _1_365
+_1_360:
+MOV EAX,[_cptr2]
+MOV DWORD [_cptr],EAX
+_1_365:
+JMP _1_357
+_1_358:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_locptr],EAX
+MOV EAX,-1
+MOV DWORD [_declared],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_1_343 DB 125,0,110,111,32,102,105,110,97,108
+ DB 32,125,0
+_doif:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+LEA EAX,[EBP-4]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _test
+ADD ESP,8
+XOR CL,CL
+CALL _statemen
+MOV EAX,_1_366+0
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JE _1_368
+JMP _1_367
+_1_368:
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_1_367:
+LEA EAX,[EBP-8]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+MOV EAX,[_lastst]
+MOV EBX,EAX
+MOV EAX,3
+CALL __ne
+OR EAX,EAX
+JNE _1_372
+JMP _1_370
+_1_372:
+MOV EAX,[_lastst]
+MOV EBX,EAX
+MOV EAX,13
+CALL __ne
+OR EAX,EAX
+JNE _1_373
+JMP _1_370
+_1_373:
+MOV EAX,1
+JMP _1_371
+_1_370:
+XOR EAX,EAX
+_1_371:
+OR EAX,EAX
+JNE _1_374
+JMP _1_369
+_1_374:
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_1_369:
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _statemen
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_1_366 DB 101,108,115,101,0
+_dowhile:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-16
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,1
+CALL _addwhile
+ADD ESP,4
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _test
+ADD ESP,8
+XOR CL,CL
+CALL _statemen
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _delwhile
+MOV ESP,EBP
+POP EBP
+RET
+_dodo:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-16
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,1
+CALL _addwhile
+ADD ESP,4
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _statemen
+MOV EAX,_1_376+0
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _test
+ADD ESP,8
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _delwhile
+XOR CL,CL
+CALL _ns
+MOV ESP,EBP
+POP EBP
+RET
+_1_376 DB 119,104,105,108,101,0
+_dofor:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-24
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,1
+CALL _addwhile
+ADD ESP,4
+LEA EAX,[EBP-20]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-24]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+MOV EAX,_1_377+0
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+MOV EAX,_1_377+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_379
+JMP _1_378
+_1_379:
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _doexpr
+ADD ESP,4
+XOR CL,CL
+CALL _ns
+_1_378:
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,_1_377+4
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_381
+JMP _1_380
+_1_381:
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _test
+ADD ESP,8
+XOR CL,CL
+CALL _ns
+_1_380:
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,_1_377+6
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _1_383
+JMP _1_382
+_1_383:
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _doexpr
+ADD ESP,4
+MOV EAX,_1_377+8
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+_1_382:
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _statemen
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _delwhile
+MOV ESP,EBP
+POP EBP
+RET
+_1_377 DB 40,0,59,0,59,0,41,0,41,0
+_doswitch:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-36
+LEA EAX,[EBP-24]
+PUSH EAX
+MOV EAX,[_swactive]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV EAX,[_swdefaul]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-32]
+PUSH EAX
+LEA EAX,[EBP-36]
+PUSH EAX
+MOV EAX,[_swnext]
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,1
+CALL _addwhile
+ADD ESP,4
+MOV EAX,[_wqptr]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,12
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV EAX,_1_384+0
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _doexpr
+ADD ESP,4
+MOV EAX,_1_384+2
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+XOR EAX,EAX
+MOV DWORD [_swdefaul],EAX
+MOV EAX,1
+MOV DWORD [_swactive],EAX
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-20]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _statemen
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,72
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_1_385:
+LEA EAX,[EBP-36]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_swnext]
+POP EBX
+CALL __ult
+OR EAX,EAX
+JNE _1_387
+JMP _1_386
+_1_387:
+MOV EAX,56
+PUSH EAX
+LEA EAX,[EBP-36]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+INC EAX
+INC EAX
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+DEC EAX
+DEC EAX
+DEC EAX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,112
+PUSH EAX
+LEA EAX,[EBP-36]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+INC EAX
+INC EAX
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+DEC EAX
+DEC EAX
+DEC EAX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _1_385
+_1_386:
+MOV EAX,112
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,[_swdefaul]
+OR EAX,EAX
+JNE _1_389
+JMP _1_388
+_1_389:
+MOV EAX,40
+PUSH EAX
+MOV EAX,[_swdefaul]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_1_388:
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _delwhile
+LEA EAX,[EBP-32]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_swnext],EAX
+LEA EAX,[EBP-28]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_swdefaul],EAX
+LEA EAX,[EBP-24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_swactive],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_1_384 DB 40,0,41,0
+_docase:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_swactive]
+OR EAX,EAX
+JE _1_392
+JMP _1_391
+_1_392:
+MOV EAX,_1_390+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_391:
+MOV EAX,[_swnext]
+PUSH EAX
+MOV EAX,[_swend]
+POP EBX
+CALL __ugt
+OR EAX,EAX
+JNE _1_394
+JMP _1_393
+_1_394:
+MOV EAX,_1_390+14
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+POP EBP
+RET
+_1_393:
+MOV EAX,41
+PUSH EAX
+MOV EAX,[_swnext]
+INC EAX
+INC EAX
+INC EAX
+INC EAX
+MOV DWORD [_swnext],EAX
+DEC EAX
+DEC EAX
+DEC EAX
+DEC EAX
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,[_swnext]
+INC EAX
+INC EAX
+INC EAX
+INC EAX
+MOV DWORD [_swnext],EAX
+DEC EAX
+DEC EAX
+DEC EAX
+DEC EAX
+PUSH EAX
+MOV CL,1
+CALL _constexp
+ADD ESP,4
+MOV EAX,_1_390+29
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+POP EBP
+RET
+_1_390 DB 110,111,116,32,105,110,32,115,119,105
+ DB 116,99,104,0,116,111,111,32,109,97
+ DB 110,121,32,99,97,115,101,115,0,58
+ DB 0
+_dodefaul:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_swactive]
+OR EAX,EAX
+JNE _1_397
+JMP _1_396
+_1_397:
+MOV EAX,[_swdefaul]
+OR EAX,EAX
+JNE _1_399
+JMP _1_398
+_1_399:
+MOV EAX,_1_395+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_398:
+JMP _1_400
+_1_396:
+MOV EAX,_1_395+18
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_400:
+MOV EAX,_1_395+32
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+MOV EAX,41
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+MOV DWORD [_swdefaul],EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+POP EBP
+RET
+_1_395 DB 109,117,108,116,105,112,108,101,32,100
+ DB 101,102,97,117,108,116,115,0,110,111
+ DB 116,32,105,110,32,115,119,105,116,99
+ DB 104,0,58,0
+_dogoto:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_nogo]
+OR EAX,EAX
+JG _1_403
+JMP _1_402
+_1_403:
+MOV EAX,_1_401+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _1_404
+_1_402:
+MOV EAX,1
+MOV DWORD [_noloc],EAX
+_1_404:
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JNE _1_406
+JMP _1_405
+_1_406:
+MOV EAX,40
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _addlabel
+ADD ESP,4
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _1_407
+_1_405:
+MOV EAX,_1_401+30
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_1_407:
+XOR CL,CL
+CALL _ns
+POP EBP
+RET
+_1_401 DB 110,111,116,32,97,108,108,111,119,101
+ DB 100,32,119,105,116,104,32,98,108,111
+ DB 99,107,45,108,111,99,97,108,115,0
+ DB 98,97,100,32,108,97,98,101,108,0
+_dolabel:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+XOR CL,CL
+CALL _blanks
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_lptr]
+POP EBX
+MOV [EBX],EAX
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JNE _1_410
+JMP _1_409
+_1_410:
+XOR CL,CL
+CALL _gch
+MOV EBX,EAX
+MOV EAX,58
+CALL __eq
+OR EAX,EAX
+JNE _1_412
+JMP _1_411
+_1_412:
+MOV EAX,41
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _addlabel
+ADD ESP,4
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_1_411:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_lptr]
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+_1_413:
+_1_409:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_addlabel:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_ssname
+PUSH EAX
+MOV CL,1
+CALL _findloc
+ADD ESP,4
+MOV DWORD [_cptr],EAX
+OR EAX,EAX
+JNE _1_416
+JMP _1_415
+_1_416:
+MOV EAX,[_cptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _1_418
+JMP _1_417
+_1_418:
+MOV EAX,_1_414+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _1_419
+_1_417:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _1_421
+JMP _1_420
+_1_421:
+MOV EAX,[_cptr]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _1_423
+JMP _1_422
+_1_423:
+MOV EAX,_1_414+12
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _1_424
+_1_422:
+MOV EAX,[_cptr]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],AL
+_1_424:
+_1_420:
+_1_419:
+JMP _1_425
+_1_415:
+MOV EAX,_ssname
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+PUSH EAX
+MOV EAX,_locptr
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,7
+CALL _addsym
+ADD ESP,28
+MOV DWORD [_cptr],EAX
+_1_425:
+MOV EAX,[_cptr]
+MOV EBX,5
+ADD EAX,EBX
+MOV EBX,2
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _getint
+ADD ESP,8
+POP EBP
+RET
+_1_414 DB 110,111,116,32,97,32,108,97,98,101
+ DB 108,0,100,117,112,108,105,99,97,116
+ DB 101,32,108,97,98,101,108,0
+_doreturn:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+XOR CL,CL
+CALL _endst
+OR EAX,EAX
+JE _1_428
+JMP _1_427
+_1_428:
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _doexpr
+ADD ESP,4
+_1_427:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_csp]
+POP EBX
+MOV [EBX],EAX
+MOV EAX,67
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_csp],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_dobreak:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_wqptr]
+PUSH EAX
+MOV CL,1
+CALL _readwhil
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JE _1_431
+JMP _1_430
+_1_431:
+MOV ESP,EBP
+POP EBP
+RET
+_1_430:
+MOV EAX,2
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_docont:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_wqptr]
+POP EBX
+MOV [EBX],EAX
+_1_433:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _readwhil
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JE _1_436
+JMP _1_435
+_1_436:
+MOV ESP,EBP
+POP EBP
+RET
+_1_435:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _1_438
+JMP _1_437
+_1_438:
+JMP _1_434
+_1_437:
+JMP _1_433
+_1_434:
+MOV EAX,2
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_doasm:
+PUSH EBP
+MOV EBP,ESP
+XOR EAX,EAX
+MOV DWORD [_ccode],EAX
+_1_440:
+XOR CL,CL
+CALL _inline
+MOV EAX,_1_439+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _1_443
+JMP _1_442
+_1_443:
+JMP _1_441
+_1_442:
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _1_445
+JMP _1_444
+_1_445:
+JMP _1_441
+_1_444:
+MOV EAX,[_line]
+PUSH EAX
+MOV EAX,[_output]
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+JMP _1_440
+_1_441:
+XOR CL,CL
+CALL _kill
+MOV EAX,1
+MOV DWORD [_ccode],EAX
+POP EBP
+RET
+_1_439 DB 35,101,110,100,97,115,109,0
+_doexpr:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-16
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_usexpr],EAX
+_1_447:
+LEA EAX,[EBP-12]
+PUSH EAX
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,2
+CALL _setstage
+ADD ESP,8
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV CL,2
+CALL _expressi
+ADD ESP,8
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,44
+CALL __ne
+OR EAX,EAX
+JNE _1_450
+JMP _1_449
+_1_450:
+JMP _1_448
+_1_449:
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+JMP _1_447
+_1_448:
+MOV EAX,1
+MOV DWORD [_usexpr],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_ask:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+LEA EAX,[EBP-4]
+PUSH EAX
+XOR EAX,EAX
+MOV DWORD [_nxtlab],EAX
+MOV DWORD [_listfp],EAX
+POP EBX
+MOV [EBX],EAX
+MOV EAX,__iob
+MOV EBX,32
+ADD EAX,EBX
+MOV DWORD [_output],EAX
+XOR EAX,EAX
+MOV BYTE [_optimize],AL
+XOR EAX,EAX
+MOV BYTE [_pause],AL
+MOV BYTE [_monitor],AL
+MOV BYTE [_alarm],AL
+MOV EAX,[_mline]
+MOV DWORD [_line],EAX
+_1_452:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+PUSH EAX
+MOV EAX,[_line]
+PUSH EAX
+MOV EAX,128
+PUSH EAX
+MOV EAX,[_argcs]
+PUSH EAX
+MOV EAX,[_argvs]
+PUSH EAX
+MOV CL,5
+CALL _getarg
+ADD ESP,20
+MOV EBX,EAX
+MOV EAX,-1
+CALL __ne
+OR EAX,EAX
+JNE _1_454
+JMP _1_453
+_1_454:
+MOV EAX,[_line]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,45
+CALL __ne
+OR EAX,EAX
+JNE _1_458
+JMP _1_456
+_1_458:
+MOV EAX,[_line]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,47
+CALL __ne
+OR EAX,EAX
+JNE _1_459
+JMP _1_456
+_1_459:
+MOV EAX,1
+JMP _1_457
+_1_456:
+XOR EAX,EAX
+_1_457:
+OR EAX,EAX
+JNE _1_460
+JMP _1_455
+_1_460:
+JMP _1_452
+_1_455:
+MOV EAX,[_line]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,76
+CALL __eq
+OR EAX,EAX
+JNE _1_464
+JMP _1_462
+_1_464:
+MOV EAX,[_line]
+MOV EBX,2
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _isdigit
+ADD ESP,4
+OR EAX,EAX
+JNE _1_465
+JMP _1_462
+_1_465:
+MOV EAX,[_line]
+MOV EBX,3
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __le
+OR EAX,EAX
+JNE _1_466
+JMP _1_462
+_1_466:
+MOV EAX,1
+JMP _1_463
+_1_462:
+XOR EAX,EAX
+_1_463:
+OR EAX,EAX
+JNE _1_467
+JMP _1_461
+_1_467:
+MOV EAX,[_line]
+MOV EBX,2
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,48
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV DWORD [_listfp],EAX
+JMP _1_452
+_1_461:
+MOV EAX,[_line]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,78
+CALL __eq
+OR EAX,EAX
+JNE _1_471
+JMP _1_469
+_1_471:
+MOV EAX,[_line]
+MOV EBX,2
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,79
+CALL __eq
+OR EAX,EAX
+JNE _1_472
+JMP _1_469
+_1_472:
+MOV EAX,[_line]
+MOV EBX,3
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __le
+OR EAX,EAX
+JNE _1_473
+JMP _1_469
+_1_473:
+MOV EAX,1
+JMP _1_470
+_1_469:
+XOR EAX,EAX
+_1_470:
+OR EAX,EAX
+JNE _1_474
+JMP _1_468
+_1_474:
+XOR EAX,EAX
+MOV BYTE [_optimize],AL
+JMP _1_452
+_1_468:
+MOV EAX,[_line]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,68
+CALL __eq
+OR EAX,EAX
+JNE _1_476
+JMP _1_475
+_1_476:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV EAX,[_line]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,2
+ADD EAX,EBX
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV DWORD [_ch],EAX
+MOV EAX,[_line]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,2
+ADD EAX,EBX
+MOV DWORD [_lptr],EAX
+XOR CL,CL
+CALL _dodefine
+JMP _1_452
+_1_475:
+MOV EAX,[_line]
+MOV EBX,2
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __le
+OR EAX,EAX
+JNE _1_478
+JMP _1_477
+_1_478:
+MOV EAX,[_line]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,65
+CALL __eq
+OR EAX,EAX
+JNE _1_480
+JMP _1_479
+_1_480:
+MOV EAX,1
+MOV BYTE [_alarm],AL
+JMP _1_452
+_1_479:
+MOV EAX,[_line]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,77
+CALL __eq
+OR EAX,EAX
+JNE _1_482
+JMP _1_481
+_1_482:
+MOV EAX,1
+MOV BYTE [_monitor],AL
+JMP _1_452
+_1_481:
+MOV EAX,[_line]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,80
+CALL __eq
+OR EAX,EAX
+JNE _1_484
+JMP _1_483
+_1_484:
+MOV EAX,1
+MOV BYTE [_pause],AL
+JMP _1_452
+_1_483:
+_1_477:
+MOV EAX,_1_451+0
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_451+57
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_451+74
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_451+89
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_451+104
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_451+118
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,_1_451+139
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,7
+PUSH EAX
+MOV CL,1
+CALL _OS_exit
+ADD ESP,4
+JMP _1_452
+_1_453:
+MOV ESP,EBP
+POP EBP
+RET
+_1_451 DB 117,115,97,103,101,58,32,99,99,32
+ DB 91,102,105,108,101,93,46,46,46,32
+ DB 91,45,109,93,32,91,45,97,93,32
+ DB 91,45,112,93,32,91,45,108,35,93
+ DB 32,91,45,110,111,93,32,91,45,100
+ DB 60,105,100,62,93,10,0,32,45,109
+ DB 32,32,32,32,32,109,111,110,105,116
+ DB 111,114,10,0,32,45,97,32,32,32
+ DB 32,32,97,108,97,114,109,10,0,32
+ DB 45,112,32,32,32,32,32,112,97,117
+ DB 115,101,10,0,32,45,108,35,32,32
+ DB 32,32,108,105,115,116,10,0,32,45
+ DB 110,111,32,32,32,32,110,111,32,111
+ DB 112,116,105,109,105,122,101,10,0,32
+ DB 45,100,60,105,100,62,32,112,114,101
+ DB 45,35,100,101,102,105,110,101,32,105
+ DB 100,10,0
+_openfile:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-28
+MOV EAX,-1
+MOV DWORD [_input],EAX
+_1_486:
+MOV EAX,[_filearg]
+INC EAX
+MOV DWORD [_filearg],EAX
+PUSH EAX
+MOV EAX,[_pline]
+PUSH EAX
+MOV EAX,128
+PUSH EAX
+MOV EAX,[_argcs]
+PUSH EAX
+MOV EAX,[_argvs]
+PUSH EAX
+MOV CL,5
+CALL _getarg
+ADD ESP,20
+MOV EBX,EAX
+MOV EAX,-1
+CALL __ne
+OR EAX,EAX
+JNE _1_488
+JMP _1_487
+_1_488:
+MOV EAX,[_pline]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,45
+CALL __eq
+OR EAX,EAX
+JE _1_492
+JMP _1_490
+_1_492:
+MOV EAX,[_pline]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,47
+CALL __eq
+OR EAX,EAX
+JE _1_493
+JMP _1_490
+_1_493:
+XOR EAX,EAX
+JMP _1_491
+_1_490:
+MOV EAX,1
+_1_491:
+OR EAX,EAX
+JNE _1_494
+JMP _1_489
+_1_494:
+JMP _1_486
+_1_489:
+LEA EAX,[EBP-28]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX,-1
+MOV [EBX],EAX
+LEA EAX,[EBP-24]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_1_495:
+MOV EAX,[_pline]
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _1_497
+JMP _1_496
+_1_497:
+MOV EAX,[_pline]
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,46
+CALL __eq
+OR EAX,EAX
+JNE _1_499
+JMP _1_498
+_1_499:
+LEA EAX,[EBP-28]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+JMP _1_496
+_1_498:
+LEA EAX,[EBP-24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,10
+CALL __lt
+OR EAX,EAX
+JNE _1_501
+JMP _1_500
+_1_501:
+LEA EAX,[EBP-16]
+PUSH EAX
+LEA EAX,[EBP-24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,[_pline]
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+_1_500:
+JMP _1_495
+_1_496:
+LEA EAX,[EBP-28]
+MOV EBX,EAX
+MOV EAX, [EBX]
+CALL __lneg
+OR EAX,EAX
+JNE _1_503
+JMP _1_502
+_1_503:
+MOV EAX,[_pline]
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,_1_485+0
+PUSH EAX
+MOV CL,2
+CALL _strcpy
+ADD ESP,8
+_1_502:
+MOV EAX,[_pline]
+PUSH EAX
+MOV EAX,_1_485+3
+PUSH EAX
+MOV CL,2
+CALL _mustopen
+ADD ESP,8
+MOV DWORD [_input],EAX
+MOV EAX,[_files]
+CALL __lneg
+OR EAX,EAX
+JNE _1_505
+JMP _1_504
+_1_505:
+LEA EAX,[EBP-16]
+PUSH EAX
+LEA EAX,[EBP-24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,_1_485+5
+PUSH EAX
+MOV CL,2
+CALL _strcpy
+ADD ESP,8
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV EAX,_1_485+10
+PUSH EAX
+MOV CL,2
+CALL _mustopen
+ADD ESP,8
+MOV DWORD [_output],EAX
+_1_504:
+MOV EAX,1
+MOV DWORD [_files],EAX
+XOR CL,CL
+CALL _kill
+MOV ESP,EBP
+POP EBP
+RET
+JMP _1_486
+_1_487:
+MOV EAX,[_files]
+INC EAX
+MOV DWORD [_files],EAX
+DEC EAX
+OR EAX,EAX
+JNE _1_507
+JMP _1_506
+_1_507:
+MOV EAX,1
+MOV DWORD [_eof],EAX
+JMP _1_508
+_1_506:
+MOV EAX,__iob
+MOV DWORD [_input],EAX
+_1_508:
+XOR CL,CL
+CALL _kill
+MOV ESP,EBP
+POP EBP
+RET
+_1_485 DB 46,67,0,114,0,46,65,83,77,0
+ DB 119,0
+_mustopen:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _OS_fopen
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _1_511
+JMP _1_510
+_1_511:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_1_510:
+MOV EAX,_1_509+0
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _lout
+ADD ESP,8
+MOV EAX,7
+PUSH EAX
+MOV CL,1
+CALL _OS_exit
+ADD ESP,4
+MOV ESP,EBP
+POP EBP
+RET
+_1_509 DB 111,112,101,110,32,101,114,114,111,114
+ DB 32,111,110,32,0

 /programs/develop/scc/CC2.ASM
 ,0 → 1,3034
+_preproce:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+MOV EAX,[_ccode]
+OR EAX,EAX
+JNE _2_3
+JMP _2_2
+_2_3:
+MOV EAX,[_mline]
+MOV DWORD [_line],EAX
+XOR CL,CL
+CALL _ifline
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _2_5
+JMP _2_4
+_2_5:
+MOV ESP,EBP
+POP EBP
+RET
+_2_4:
+JMP _2_6
+_2_2:
+XOR CL,CL
+CALL _inline
+MOV ESP,EBP
+POP EBP
+RET
+_2_6:
+MOV EAX,-1
+MOV DWORD [_pptr],EAX
+_2_7:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,10
+CALL __ne
+OR EAX,EAX
+JNE _2_11
+JMP _2_9
+_2_11:
+MOV EAX,[_ch]
+OR EAX,EAX
+JNE _2_12
+JMP _2_9
+_2_12:
+MOV EAX,1
+JMP _2_10
+_2_9:
+XOR EAX,EAX
+_2_10:
+OR EAX,EAX
+JNE _2_13
+JMP _2_8
+_2_13:
+XOR CL,CL
+CALL _white
+OR EAX,EAX
+JNE _2_15
+JMP _2_14
+_2_15:
+MOV EAX,32
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+_2_16:
+XOR CL,CL
+CALL _white
+OR EAX,EAX
+JNE _2_18
+JMP _2_17
+_2_18:
+XOR CL,CL
+CALL _gch
+JMP _2_16
+_2_17:
+JMP _2_19
+_2_14:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,34
+CALL __eq
+OR EAX,EAX
+JNE _2_21
+JMP _2_20
+_2_21:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+XOR CL,CL
+CALL _gch
+_2_22:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,34
+CALL __ne
+OR EAX,EAX
+JE _2_28
+JMP _2_24
+_2_28:
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOV EAX,1
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,92
+CALL __eq
+OR EAX,EAX
+JNE _2_29
+JMP _2_25
+_2_29:
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOV EAX,2
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,92
+CALL __ne
+OR EAX,EAX
+JNE _2_30
+JMP _2_25
+_2_30:
+MOV EAX,1
+JMP _2_26
+_2_25:
+XOR EAX,EAX
+_2_26:
+OR EAX,EAX
+JE _2_31
+JMP _2_24
+_2_31:
+XOR EAX,EAX
+JMP _2_27
+_2_24:
+MOV EAX,1
+_2_27:
+OR EAX,EAX
+JNE _2_32
+JMP _2_23
+_2_32:
+MOV EAX,[_ch]
+OR EAX,EAX
+JE _2_34
+JMP _2_33
+_2_34:
+MOV EAX,_2_1+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _2_23
+_2_33:
+XOR CL,CL
+CALL _gch
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+JMP _2_22
+_2_23:
+XOR CL,CL
+CALL _gch
+MOV EAX,34
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+JMP _2_35
+_2_20:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,39
+CALL __eq
+OR EAX,EAX
+JNE _2_37
+JMP _2_36
+_2_37:
+MOV EAX,39
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+XOR CL,CL
+CALL _gch
+_2_38:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,39
+CALL __ne
+OR EAX,EAX
+JE _2_44
+JMP _2_40
+_2_44:
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOV EAX,1
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,92
+CALL __eq
+OR EAX,EAX
+JNE _2_45
+JMP _2_41
+_2_45:
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOV EAX,2
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,92
+CALL __ne
+OR EAX,EAX
+JNE _2_46
+JMP _2_41
+_2_46:
+MOV EAX,1
+JMP _2_42
+_2_41:
+XOR EAX,EAX
+_2_42:
+OR EAX,EAX
+JE _2_47
+JMP _2_40
+_2_47:
+XOR EAX,EAX
+JMP _2_43
+_2_40:
+MOV EAX,1
+_2_43:
+OR EAX,EAX
+JNE _2_48
+JMP _2_39
+_2_48:
+MOV EAX,[_ch]
+OR EAX,EAX
+JE _2_50
+JMP _2_49
+_2_50:
+MOV EAX,_2_1+9
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _2_39
+_2_49:
+XOR CL,CL
+CALL _gch
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+JMP _2_38
+_2_39:
+XOR CL,CL
+CALL _gch
+MOV EAX,39
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+JMP _2_51
+_2_36:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,47
+CALL __eq
+OR EAX,EAX
+JNE _2_55
+JMP _2_53
+_2_55:
+MOV EAX,[_nch]
+MOV EBX,EAX
+MOV EAX,42
+CALL __eq
+OR EAX,EAX
+JNE _2_56
+JMP _2_53
+_2_56:
+MOV EAX,1
+JMP _2_54
+_2_53:
+XOR EAX,EAX
+_2_54:
+OR EAX,EAX
+JNE _2_57
+JMP _2_52
+_2_57:
+MOV EAX,2
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+_2_58:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,42
+CALL __eq
+OR EAX,EAX
+JNE _2_62
+JMP _2_60
+_2_62:
+MOV EAX,[_nch]
+MOV EBX,EAX
+MOV EAX,47
+CALL __eq
+OR EAX,EAX
+JNE _2_63
+JMP _2_60
+_2_63:
+MOV EAX,1
+JMP _2_61
+_2_60:
+XOR EAX,EAX
+_2_61:
+OR EAX,EAX
+JE _2_64
+JMP _2_59
+_2_64:
+MOV EAX,[_ch]
+OR EAX,EAX
+JNE _2_66
+JMP _2_65
+_2_66:
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+JMP _2_67
+_2_65:
+XOR CL,CL
+CALL _ifline
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _2_69
+JMP _2_68
+_2_69:
+JMP _2_59
+_2_68:
+_2_67:
+JMP _2_58
+_2_59:
+MOV EAX,2
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+JMP _2_70
+_2_52:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,47
+CALL __eq
+OR EAX,EAX
+JNE _2_74
+JMP _2_72
+_2_74:
+MOV EAX,[_nch]
+MOV EBX,EAX
+MOV EAX,47
+CALL __eq
+OR EAX,EAX
+JNE _2_75
+JMP _2_72
+_2_75:
+MOV EAX,1
+JMP _2_73
+_2_72:
+XOR EAX,EAX
+_2_73:
+OR EAX,EAX
+JNE _2_76
+JMP _2_71
+_2_76:
+MOV EAX,2
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+_2_77:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,10
+CALL __ne
+OR EAX,EAX
+JNE _2_79
+JMP _2_78
+_2_79:
+MOV EAX,[_ch]
+OR EAX,EAX
+JNE _2_81
+JMP _2_80
+_2_81:
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+JMP _2_82
+_2_80:
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _2_84
+JMP _2_83
+_2_84:
+JMP _2_78
+_2_83:
+_2_82:
+JMP _2_77
+_2_78:
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+JMP _2_85
+_2_71:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JNE _2_87
+JMP _2_86
+_2_87:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_2_88:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JNE _2_92
+JMP _2_90
+_2_92:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,8
+CALL __lt
+OR EAX,EAX
+JNE _2_93
+JMP _2_90
+_2_93:
+MOV EAX,1
+JMP _2_91
+_2_90:
+XOR EAX,EAX
+_2_91:
+OR EAX,EAX
+JNE _2_94
+JMP _2_89
+_2_94:
+MOV EAX,_msname
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,[_ch]
+POP EBX
+MOV [EBX],AL
+XOR CL,CL
+CALL _gch
+JMP _2_88
+_2_89:
+MOV EAX,_msname
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+MOV EAX,_msname
+PUSH EAX
+MOV EAX,[_macn]
+PUSH EAX
+MOV EAX,11
+PUSH EAX
+MOV EAX,[_macn]
+MOV EBX,3300
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,300
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,6
+CALL _search
+ADD ESP,24
+OR EAX,EAX
+JNE _2_96
+JMP _2_95
+_2_96:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_cptr]
+MOV EBX,9
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,2
+PUSH EAX
+MOV CL,2
+CALL _getint
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+_2_97:
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV EAX,[_macq]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+OR EAX,EAX
+JNE _2_99
+JMP _2_98
+_2_99:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+JMP _2_97
+_2_98:
+_2_100:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JNE _2_102
+JMP _2_101
+_2_102:
+XOR CL,CL
+CALL _gch
+JMP _2_100
+_2_101:
+JMP _2_103
+_2_95:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_2_104:
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV EAX,_msname
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+OR EAX,EAX
+JNE _2_106
+JMP _2_105
+_2_106:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+JMP _2_104
+_2_105:
+_2_103:
+JMP _2_107
+_2_86:
+XOR CL,CL
+CALL _gch
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+_2_107:
+_2_85:
+_2_70:
+_2_51:
+_2_35:
+_2_19:
+JMP _2_7
+_2_8:
+MOV EAX,[_pptr]
+MOV EBX,EAX
+MOV EAX,127
+CALL __ge
+OR EAX,EAX
+JNE _2_109
+JMP _2_108
+_2_109:
+MOV EAX,_2_1+23
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_2_108:
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _keepch
+ADD ESP,4
+MOV EAX,[_pline]
+MOV DWORD [_line],EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+MOV ESP,EBP
+POP EBP
+RET
+_2_1 DB 110,111,32,113,117,111,116,101,0,110
+ DB 111,32,97,112,111,115,116,114,111,112
+ DB 104,101,0,108,105,110,101,32,116,111
+ DB 111,32,108,111,110,103,0
+_keepch:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_pptr]
+MOV EBX,EAX
+MOV EAX,127
+CALL __lt
+OR EAX,EAX
+JNE _2_112
+JMP _2_111
+_2_112:
+MOV EAX,[_pline]
+PUSH EAX
+MOV EAX,[_pptr]
+INC EAX
+MOV DWORD [_pptr],EAX
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+_2_111:
+POP EBP
+RET
+_ifline:
+PUSH EBP
+MOV EBP,ESP
+_2_114:
+XOR CL,CL
+CALL _inline
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _2_117
+JMP _2_116
+_2_117:
+POP EBP
+RET
+_2_116:
+MOV EAX,_2_113+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _2_119
+JMP _2_118
+_2_119:
+MOV EAX,[_iflevel]
+INC EAX
+MOV DWORD [_iflevel],EAX
+MOV EAX,[_skipleve]
+OR EAX,EAX
+JNE _2_121
+JMP _2_120
+_2_121:
+JMP _2_114
+_2_120:
+MOV EAX,_msname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+MOV EAX,_msname
+PUSH EAX
+MOV EAX,[_macn]
+PUSH EAX
+MOV EAX,11
+PUSH EAX
+MOV EAX,[_macn]
+MOV EBX,3300
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,300
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,6
+CALL _search
+ADD ESP,24
+OR EAX,EAX
+JE _2_123
+JMP _2_122
+_2_123:
+MOV EAX,[_iflevel]
+MOV DWORD [_skipleve],EAX
+_2_122:
+JMP _2_114
+_2_118:
+MOV EAX,_2_113+7
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _2_125
+JMP _2_124
+_2_125:
+MOV EAX,[_iflevel]
+INC EAX
+MOV DWORD [_iflevel],EAX
+MOV EAX,[_skipleve]
+OR EAX,EAX
+JNE _2_127
+JMP _2_126
+_2_127:
+JMP _2_114
+_2_126:
+MOV EAX,_msname
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+MOV EAX,_msname
+PUSH EAX
+MOV EAX,[_macn]
+PUSH EAX
+MOV EAX,11
+PUSH EAX
+MOV EAX,[_macn]
+MOV EBX,3300
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,300
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,6
+CALL _search
+ADD ESP,24
+OR EAX,EAX
+JNE _2_129
+JMP _2_128
+_2_129:
+MOV EAX,[_iflevel]
+MOV DWORD [_skipleve],EAX
+_2_128:
+JMP _2_114
+_2_124:
+MOV EAX,_2_113+15
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _2_131
+JMP _2_130
+_2_131:
+MOV EAX,[_iflevel]
+OR EAX,EAX
+JNE _2_133
+JMP _2_132
+_2_133:
+MOV EAX,[_skipleve]
+PUSH EAX
+MOV EAX,[_iflevel]
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_135
+JMP _2_134
+_2_135:
+XOR EAX,EAX
+MOV DWORD [_skipleve],EAX
+JMP _2_136
+_2_134:
+MOV EAX,[_skipleve]
+OR EAX,EAX
+JE _2_138
+JMP _2_137
+_2_138:
+MOV EAX,[_iflevel]
+MOV DWORD [_skipleve],EAX
+_2_137:
+_2_136:
+JMP _2_139
+_2_132:
+XOR CL,CL
+CALL _noiferr
+_2_139:
+JMP _2_114
+_2_130:
+MOV EAX,_2_113+21
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _2_141
+JMP _2_140
+_2_141:
+MOV EAX,[_iflevel]
+OR EAX,EAX
+JNE _2_143
+JMP _2_142
+_2_143:
+MOV EAX,[_skipleve]
+PUSH EAX
+MOV EAX,[_iflevel]
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_145
+JMP _2_144
+_2_145:
+XOR EAX,EAX
+MOV DWORD [_skipleve],EAX
+_2_144:
+MOV EAX,[_iflevel]
+DEC EAX
+MOV DWORD [_iflevel],EAX
+JMP _2_146
+_2_142:
+XOR CL,CL
+CALL _noiferr
+_2_146:
+JMP _2_114
+_2_140:
+MOV EAX,[_skipleve]
+OR EAX,EAX
+JNE _2_148
+JMP _2_147
+_2_148:
+JMP _2_114
+_2_147:
+MOV EAX,[_ch]
+OR EAX,EAX
+JE _2_150
+JMP _2_149
+_2_150:
+JMP _2_114
+_2_149:
+JMP _2_115
+JMP _2_114
+_2_115:
+POP EBP
+RET
+_2_113 DB 35,105,102,100,101,102,0,35,105,102
+ DB 110,100,101,102,0,35,101,108,115,101
+ DB 0,35,101,110,100,105,102,0
+_inline:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+MOV EAX,[_input]
+MOV EBX,EAX
+MOV EAX,-1
+CALL __eq
+OR EAX,EAX
+JNE _2_153
+JMP _2_152
+_2_153:
+XOR CL,CL
+CALL _openfile
+_2_152:
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _2_155
+JMP _2_154
+_2_155:
+MOV ESP,EBP
+POP EBP
+RET
+_2_154:
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV EAX,[_input2]
+POP EBX
+MOV [EBX],EAX
+MOV EBX,EAX
+MOV EAX,-1
+CALL __eq
+OR EAX,EAX
+JNE _2_157
+JMP _2_156
+_2_157:
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV EAX,[_input]
+POP EBX
+MOV [EBX],EAX
+_2_156:
+MOV EAX,[_line]
+PUSH EAX
+MOV EAX,127
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _fgets
+ADD ESP,12
+OR EAX,EAX
+JE _2_159
+JMP _2_158
+_2_159:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _OS_fclos
+ADD ESP,4
+MOV EAX,[_input2]
+MOV EBX,EAX
+MOV EAX,-1
+CALL __ne
+OR EAX,EAX
+JNE _2_161
+JMP _2_160
+_2_161:
+MOV EAX,-1
+MOV DWORD [_input2],EAX
+JMP _2_162
+_2_160:
+MOV EAX,-1
+MOV DWORD [_input],EAX
+_2_162:
+MOV EAX,[_line]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+JMP _2_163
+_2_158:
+MOV EAX,[_listfp]
+OR EAX,EAX
+JNE _2_165
+JMP _2_164
+_2_165:
+MOV EAX,[_listfp]
+PUSH EAX
+MOV EAX,[_output]
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_167
+JMP _2_166
+_2_167:
+MOV EAX,59
+PUSH EAX
+MOV EAX,[_output]
+PUSH EAX
+MOV CL,2
+CALL _OS_fputc
+ADD ESP,8
+_2_166:
+MOV EAX,[_line]
+PUSH EAX
+MOV EAX,[_listfp]
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+_2_164:
+_2_163:
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+MOV ESP,EBP
+POP EBP
+RET
+_inbyte:
+PUSH EBP
+MOV EBP,ESP
+_2_169:
+MOV EAX,[_ch]
+OR EAX,EAX
+JE _2_171
+JMP _2_170
+_2_171:
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _2_173
+JMP _2_172
+_2_173:
+XOR EAX,EAX
+POP EBP
+RET
+_2_172:
+XOR CL,CL
+CALL _preproce
+JMP _2_169
+_2_170:
+XOR CL,CL
+CALL _gch
+POP EBP
+RET
+_symname:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+XOR CL,CL
+CALL _blanks
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _alpha
+ADD ESP,4
+OR EAX,EAX
+JE _2_176
+JMP _2_175
+_2_176:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+MOV ESP,EBP
+POP EBP
+RET
+_2_175:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_2_177:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JNE _2_179
+JMP _2_178
+_2_179:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+XOR CL,CL
+CALL _gch
+POP EBX
+MOV [EBX],AL
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,8
+CALL __lt
+OR EAX,EAX
+JNE _2_181
+JMP _2_180
+_2_181:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+_2_180:
+JMP _2_177
+_2_178:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_need:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _2_184
+JMP _2_183
+_2_184:
+MOV EAX,_2_182+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_2_183:
+POP EBP
+RET
+_2_182 DB 109,105,115,115,105,110,103,32,116,111
+ DB 107,101,110,0
+_ns:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_2_185+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _2_187
+JMP _2_186
+_2_187:
+MOV EAX,_2_185+2
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+JMP _2_188
+_2_186:
+XOR EAX,EAX
+MOV DWORD [_errflag],EAX
+_2_188:
+POP EBP
+RET
+_2_185 DB 59,0,110,111,32,115,101,109,105,99
+ DB 111,108,111,110,0
+_match:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+XOR CL,CL
+CALL _blanks
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _streq
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _2_191
+JMP _2_190
+_2_191:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_2_190:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_streq:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_2_193:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _2_195
+JMP _2_194
+_2_195:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+CALL __ne
+OR EAX,EAX
+JNE _2_197
+JMP _2_196
+_2_197:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_2_196:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+JMP _2_193
+_2_194:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_amatch:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+XOR CL,CL
+CALL _blanks
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _astreq
+ADD ESP,12
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _2_200
+JMP _2_199
+_2_200:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_2_199:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_astreq:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_2_202:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __lt
+OR EAX,EAX
+JNE _2_204
+JMP _2_203
+_2_204:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+CALL __ne
+OR EAX,EAX
+JNE _2_206
+JMP _2_205
+_2_206:
+JMP _2_203
+_2_205:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __lt
+OR EAX,EAX
+JNE _2_208
+JMP _2_207
+_2_208:
+JMP _2_203
+_2_207:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __lt
+OR EAX,EAX
+JNE _2_210
+JMP _2_209
+_2_210:
+JMP _2_203
+_2_209:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+JMP _2_202
+_2_203:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JE _2_214
+JMP _2_212
+_2_214:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JE _2_215
+JMP _2_212
+_2_215:
+XOR EAX,EAX
+JMP _2_213
+_2_212:
+MOV EAX,1
+_2_213:
+OR EAX,EAX
+JNE _2_216
+JMP _2_211
+_2_216:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_2_211:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_nextop:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+XOR EAX,EAX
+MOV DWORD [_opindex],EAX
+XOR CL,CL
+CALL _blanks
+_2_218:
+XOR EAX,EAX
+MOV DWORD [_opsize],EAX
+_2_220:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __gt
+OR EAX,EAX
+JNE _2_222
+JMP _2_221
+_2_222:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_opsize]
+INC EAX
+MOV DWORD [_opsize],EAX
+DEC EAX
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+JMP _2_220
+_2_221:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_opsize]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV CL,2
+CALL _streq
+ADD ESP,8
+MOV DWORD [_opsize],EAX
+OR EAX,EAX
+JNE _2_224
+JMP _2_223
+_2_224:
+MOV EAX,[_lptr]
+PUSH EAX
+MOV EAX,[_opsize]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,61
+CALL __ne
+OR EAX,EAX
+JNE _2_228
+JMP _2_226
+_2_228:
+MOV EAX,[_lptr]
+PUSH EAX
+MOV EAX,[_opsize]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV EAX,[_lptr]
+PUSH EAX
+MOV EAX,[_opsize]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,1
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+CALL __ne
+OR EAX,EAX
+JNE _2_229
+JMP _2_226
+_2_229:
+MOV EAX,1
+JMP _2_227
+_2_226:
+XOR EAX,EAX
+_2_227:
+OR EAX,EAX
+JNE _2_230
+JMP _2_225
+_2_230:
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_2_225:
+_2_223:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _2_232
+JMP _2_231
+_2_232:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+MOV EAX,[_opindex]
+INC EAX
+MOV DWORD [_opindex],EAX
+JMP _2_233
+_2_231:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_2_233:
+JMP _2_218
+_2_219:
+MOV ESP,EBP
+POP EBP
+RET
+_blanks:
+PUSH EBP
+MOV EBP,ESP
+_2_235:
+_2_237:
+MOV EAX,[_ch]
+OR EAX,EAX
+JNE _2_239
+JMP _2_238
+_2_239:
+XOR CL,CL
+CALL _white
+OR EAX,EAX
+JNE _2_241
+JMP _2_240
+_2_241:
+XOR CL,CL
+CALL _gch
+JMP _2_242
+_2_240:
+POP EBP
+RET
+_2_242:
+JMP _2_237
+_2_238:
+MOV EAX,[_line]
+PUSH EAX
+MOV EAX,[_mline]
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_244
+JMP _2_243
+_2_244:
+POP EBP
+RET
+_2_243:
+XOR CL,CL
+CALL _preproce
+MOV EAX,[_eof]
+OR EAX,EAX
+JNE _2_246
+JMP _2_245
+_2_246:
+JMP _2_236
+_2_245:
+JMP _2_235
+_2_236:
+POP EBP
+RET
+_white:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __le
+OR EAX,EAX
+JNE _2_250
+JMP _2_248
+_2_250:
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _2_251
+JMP _2_248
+_2_251:
+MOV EAX,1
+JMP _2_249
+_2_248:
+XOR EAX,EAX
+_2_249:
+POP EBP
+RET
+_gch:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_ch]
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _2_254
+JMP _2_253
+_2_254:
+MOV EAX,1
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+_2_253:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_bump:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _2_257
+JMP _2_256
+_2_257:
+MOV EAX,[_lptr]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV DWORD [_lptr],EAX
+JMP _2_258
+_2_256:
+MOV EAX,[_line]
+MOV DWORD [_lptr],EAX
+_2_258:
+MOV EAX,[_lptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV DWORD [_nch],EAX
+MOV DWORD [_ch],EAX
+OR EAX,EAX
+JNE _2_260
+JMP _2_259
+_2_260:
+MOV EAX,[_lptr]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV DWORD [_nch],EAX
+_2_259:
+POP EBP
+RET
+_kill:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_line]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+POP EBP
+RET
+_skip:
+PUSH EBP
+MOV EBP,ESP
+XOR CL,CL
+CALL _inbyte
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JNE _2_264
+JMP _2_263
+_2_264:
+_2_265:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JNE _2_267
+JMP _2_266
+_2_267:
+XOR CL,CL
+CALL _gch
+JMP _2_265
+_2_266:
+JMP _2_268
+_2_263:
+_2_269:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JE _2_271
+JMP _2_270
+_2_271:
+MOV EAX,[_ch]
+OR EAX,EAX
+JE _2_273
+JMP _2_272
+_2_273:
+JMP _2_270
+_2_272:
+XOR CL,CL
+CALL _gch
+JMP _2_269
+_2_270:
+_2_268:
+XOR CL,CL
+CALL _blanks
+POP EBP
+RET
+_endst:
+PUSH EBP
+MOV EBP,ESP
+XOR CL,CL
+CALL _blanks
+MOV EAX,[_lptr]
+PUSH EAX
+MOV EAX,_2_274+0
+PUSH EAX
+MOV CL,2
+CALL _streq
+ADD ESP,8
+OR EAX,EAX
+JE _2_277
+JMP _2_275
+_2_277:
+MOV EAX,[_ch]
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JE _2_278
+JMP _2_275
+_2_278:
+XOR EAX,EAX
+JMP _2_276
+_2_275:
+MOV EAX,1
+_2_276:
+POP EBP
+RET
+_2_274 DB 59,0
+_addsym:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,_glbptr
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_281
+JMP _2_280
+_2_281:
+LEA EAX,[EBP+32]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _findglb
+ADD ESP,4
+MOV DWORD [_cptr2],EAX
+OR EAX,EAX
+JNE _2_283
+JMP _2_282
+_2_283:
+MOV EAX,[_cptr2]
+POP EBP
+RET
+_2_282:
+MOV EAX,[_cptr]
+OR EAX,EAX
+JE _2_285
+JMP _2_284
+_2_285:
+MOV EAX,_2_279+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR EAX,EAX
+POP EBP
+RET
+_2_284:
+JMP _2_286
+_2_280:
+MOV EAX,[_locptr]
+PUSH EAX
+MOV EAX,[_symtab]
+MOV EBX,400
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,20
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+CALL __ugt
+OR EAX,EAX
+JNE _2_288
+JMP _2_287
+_2_288:
+MOV EAX,_2_279+29
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+MOV EAX,7
+PUSH EAX
+MOV CL,1
+CALL _OS_exit
+ADD ESP,4
+_2_287:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_cptr],EAX
+_2_286:
+MOV EAX,[_cptr]
+PUSH EAX
+LEA EAX,[EBP+28]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+MOV EAX,[_cptr]
+MOV EBX,1
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+MOV EAX,[_cptr]
+MOV EBX,2
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],AL
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_cptr]
+MOV EBX,3
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,3
+CALL _putint
+ADD ESP,12
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_cptr]
+MOV EBX,5
+ADD EAX,EBX
+MOV EBX,2
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,3
+CALL _putint
+ADD ESP,12
+MOV EAX,[_cptr]
+MOV EBX,11
+ADD EAX,EBX
+MOV DWORD [_cptr2],EAX
+MOV DWORD [_cptr3],EAX
+_2_289:
+LEA EAX,[EBP+32]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _an
+ADD ESP,4
+OR EAX,EAX
+JNE _2_291
+JMP _2_290
+_2_291:
+MOV EAX,[_cptr2]
+INC EAX
+MOV DWORD [_cptr2],EAX
+DEC EAX
+PUSH EAX
+LEA EAX,[EBP+32]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],AL
+JMP _2_289
+_2_290:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,_locptr
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_293
+JMP _2_292
+_2_293:
+MOV EAX,[_cptr2]
+PUSH EAX
+MOV EAX,[_cptr2]
+PUSH EAX
+MOV EAX,[_cptr3]
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+MOV [EBX],AL
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_cptr2]
+INC EAX
+MOV DWORD [_cptr2],EAX
+POP EBX
+MOV [EBX],EAX
+_2_292:
+MOV EAX,[_cptr]
+POP EBP
+RET
+_2_279 DB 103,108,111,98,97,108,32,115,121,109
+ DB 98,111,108,32,116,97,98,108,101,32
+ DB 111,118,101,114,102,108,111,119,0,108
+ DB 111,99,97,108,32,115,121,109,98,111
+ DB 108,32,116,97,98,108,101,32,111,118
+ DB 101,114,102,108,111,119,0
+_search:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+28]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _hash
+ADD ESP,4
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+XCHG EAX,EBX
+CDQ
+IDIV EBX
+MOV EAX,EDX
+PUSH EAX
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+IMUL EBX
+POP EBX
+ADD EAX,EBX
+MOV DWORD [_cptr2],EAX
+MOV DWORD [_cptr],EAX
+_2_295:
+MOV EAX,[_cptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JNE _2_297
+JMP _2_296
+_2_297:
+LEA EAX,[EBP+28]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_cptr]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,3
+CALL _astreq
+ADD ESP,12
+OR EAX,EAX
+JNE _2_299
+JMP _2_298
+_2_299:
+MOV EAX,1
+POP EBP
+RET
+_2_298:
+MOV EAX,[_cptr]
+PUSH EAX
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV DWORD [_cptr],EAX
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __uge
+OR EAX,EAX
+JNE _2_301
+JMP _2_300
+_2_301:
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV DWORD [_cptr],EAX
+_2_300:
+MOV EAX,[_cptr]
+PUSH EAX
+MOV EAX,[_cptr2]
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_303
+JMP _2_302
+_2_303:
+XOR EAX,EAX
+MOV DWORD [_cptr],EAX
+POP EBP
+RET
+_2_302:
+JMP _2_295
+_2_296:
+XOR EAX,EAX
+POP EBP
+RET
+_hash:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_2_305:
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _2_307
+JMP _2_306
+_2_307:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+JMP _2_305
+_2_306:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_findglb:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_symtab]
+MOV EBX,400
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,20
+PUSH EAX
+MOV EAX,[_symtab]
+MOV EBX,400
+ADD EAX,EBX
+MOV EBX,3980
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,200
+PUSH EAX
+MOV EAX,11
+PUSH EAX
+MOV CL,6
+CALL _search
+ADD ESP,24
+OR EAX,EAX
+JNE _2_310
+JMP _2_309
+_2_310:
+MOV EAX,[_cptr]
+POP EBP
+RET
+_2_309:
+XOR EAX,EAX
+POP EBP
+RET
+_findloc:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_locptr]
+MOV EBX,EAX
+MOV EAX,1
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV DWORD [_cptr],EAX
+_2_312:
+MOV EAX,[_cptr]
+PUSH EAX
+MOV EAX,[_symtab]
+POP EBX
+CALL __ugt
+OR EAX,EAX
+JNE _2_314
+JMP _2_313
+_2_314:
+MOV EAX,[_cptr]
+PUSH EAX
+MOV EAX,[_cptr]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV DWORD [_cptr],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_cptr]
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,3
+CALL _astreq
+ADD ESP,12
+OR EAX,EAX
+JNE _2_316
+JMP _2_315
+_2_316:
+MOV EAX,[_cptr]
+MOV EBX,EAX
+MOV EAX,11
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBP
+RET
+_2_315:
+MOV EAX,[_cptr]
+MOV EBX,EAX
+MOV EAX,11
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV EBX,EAX
+MOV EAX,1
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV DWORD [_cptr],EAX
+JMP _2_312
+_2_313:
+XOR EAX,EAX
+POP EBP
+RET
+_nextsym:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,11
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+_2_318:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,32
+CALL __ge
+OR EAX,EAX
+JNE _2_320
+JMP _2_319
+_2_320:
+JMP _2_318
+_2_319:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBP
+RET
+_addwhile:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_csp]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+MOV EAX,[_wqptr]
+PUSH EAX
+MOV EAX,[_wq]
+MOV EBX,120
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,12
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+CALL __eq
+OR EAX,EAX
+JNE _2_323
+JMP _2_322
+_2_323:
+MOV EAX,_2_321+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+MOV EAX,7
+PUSH EAX
+MOV CL,1
+CALL _OS_exit
+ADD ESP,4
+_2_322:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_2_324:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __lt
+OR EAX,EAX
+JNE _2_326
+JMP _2_325
+_2_326:
+MOV EAX,[_wqptr]
+INC EAX
+INC EAX
+INC EAX
+INC EAX
+MOV DWORD [_wqptr],EAX
+DEC EAX
+DEC EAX
+DEC EAX
+DEC EAX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+POP EBX
+SHL EAX,1
+SHL EAX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+JMP _2_324
+_2_325:
+MOV ESP,EBP
+POP EBP
+RET
+_2_321 DB 99,111,110,116,114,111,108,32,115,116
+ DB 97,116,101,109,101,110,116,32,110,101
+ DB 115,116,105,110,103,32,108,105,109,105
+ DB 116,0
+_readwhil:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_wq]
+POP EBX
+CALL __ule
+OR EAX,EAX
+JNE _2_329
+JMP _2_328
+_2_329:
+MOV EAX,_2_327+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR EAX,EAX
+POP EBP
+RET
+_2_328:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,12
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBP
+RET
+_2_330:
+POP EBP
+RET
+_2_327 DB 111,117,116,32,111,102,32,99,111,110
+ DB 116,101,120,116,0
+_delwhile:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_wqptr]
+PUSH EAX
+MOV EAX,[_wq]
+POP EBX
+CALL __ugt
+OR EAX,EAX
+JNE _2_333
+JMP _2_332
+_2_333:
+MOV EAX,[_wqptr]
+MOV EBX,EAX
+MOV EAX,12
+XCHG EAX,EBX
+SUB EAX,EBX
+MOV DWORD [_wqptr],EAX
+_2_332:
+POP EBP
+RET
+_alpha:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _isalpha
+ADD ESP,4
+OR EAX,EAX
+JE _2_337
+JMP _2_335
+_2_337:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,95
+CALL __eq
+OR EAX,EAX
+JE _2_338
+JMP _2_335
+_2_338:
+XOR EAX,EAX
+JMP _2_336
+_2_335:
+MOV EAX,1
+_2_336:
+POP EBP
+RET
+_an:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _alpha
+ADD ESP,4
+OR EAX,EAX
+JE _2_342
+JMP _2_340
+_2_342:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+PUSH EAX
+MOV CL,1
+CALL _isdigit
+ADD ESP,4
+OR EAX,EAX
+JE _2_343
+JMP _2_340
+_2_343:
+XOR EAX,EAX
+JMP _2_341
+_2_340:
+MOV EAX,1
+_2_341:
+POP EBP
+RET
+_getlabel:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_nxtlab]
+INC EAX
+MOV DWORD [_nxtlab],EAX
+POP EBP
+RET
+_getint:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+DEC EAX
+MOV [EBX],EAX
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+_2_346:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+DEC EAX
+MOV [EBX],EAX
+INC EAX
+OR EAX,EAX
+JNE _2_348
+JMP _2_347
+_2_348:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,8
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,255
+AND EAX,EBX
+POP EBX
+OR EAX,EBX
+POP EBX
+MOV [EBX],EAX
+JMP _2_346
+_2_347:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_putint:
+PUSH EBP
+MOV EBP,ESP
+_2_350:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+DEC EAX
+MOV [EBX],EAX
+INC EAX
+OR EAX,EAX
+JNE _2_352
+JMP _2_351
+_2_352:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],AL
+LEA EAX,[EBP+16]
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,8
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+POP EBX
+MOV [EBX],EAX
+JMP _2_350
+_2_351:
+POP EBP
+RET
+_lout:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+MOV EAX,10
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _OS_fputc
+ADD ESP,8
+POP EBP
+RET
+_illname:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_2_354+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR CL,CL
+CALL _skip
+POP EBP
+RET
+_2_354 DB 105,108,108,101,103,97,108,32,115,121
+ DB 109,98,111,108,0
+_multidef:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_2_355+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+POP EBP
+RET
+_2_355 DB 97,108,114,101,97,100,121,32,100,101
+ DB 102,105,110,101,100,0
+_needlval:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_2_356+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+POP EBP
+RET
+_2_356 DB 109,117,115,116,32,98,101,32,108,118
+ DB 97,108,117,101,0
+_noiferr:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_2_357+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR EAX,EAX
+MOV DWORD [_errflag],EAX
+POP EBP
+RET
+_2_357 DB 110,111,32,109,97,116,99,104,105,110
+ DB 103,32,35,105,102,46,46,46,0
+_error:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_errflag]
+OR EAX,EAX
+JNE _2_360
+JMP _2_359
+_2_360:
+POP EBP
+RET
+_2_359:
+MOV EAX,1
+MOV DWORD [_errflag],EAX
+_2_361:
+MOV EAX,[_line]
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _lout
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _errout
+ADD ESP,8
+MOVSX EAX,BYTE [_alarm]
+OR EAX,EAX
+JNE _2_363
+JMP _2_362
+_2_363:
+MOV EAX,7
+PUSH EAX
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _OS_fputc
+ADD ESP,8
+_2_362:
+MOVSX EAX,BYTE [_pause]
+OR EAX,EAX
+JNE _2_365
+JMP _2_364
+_2_365:
+_2_366:
+MOV EAX,__iob
+MOV EBX,64
+ADD EAX,EBX
+PUSH EAX
+MOV CL,1
+CALL _OS_fgetc
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,10
+CALL __ne
+OR EAX,EAX
+JNE _2_368
+JMP _2_367
+_2_368:
+JMP _2_366
+_2_367:
+_2_364:
+MOV EAX,[_listfp]
+OR EAX,EAX
+JG _2_370
+JMP _2_369
+_2_370:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_listfp]
+PUSH EAX
+MOV CL,2
+CALL _errout
+ADD ESP,8
+_2_369:
+POP EBP
+RET
+_errout:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,[_line]
+MOV EBX,2
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+_2_372:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+DEC EAX
+PUSH EAX
+MOV EAX,[_lptr]
+POP EBX
+CALL __ule
+OR EAX,EAX
+JNE _2_374
+JMP _2_373
+_2_374:
+MOV EAX,32
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _OS_fputc
+ADD ESP,8
+JMP _2_372
+_2_373:
+MOV EAX,_2_371+0
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _lout
+ADD ESP,8
+MOV EAX,_2_371+3
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _fputs
+ADD ESP,8
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _lout
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_2_371 DB 47,92,0,42,42,42,42,32,0

 /programs/develop/scc/CC3.ASM
 ,0 → 1,6740
+_constexp:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-12
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP-12]
+PUSH EAX
+MOV CL,2
+CALL _setstage
+ADD ESP,8
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _expressi
+ADD ESP,8
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_3
+JMP _3_2
+_3_3:
+MOV EAX,_3_1+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_3_2:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_1 DB 109,117,115,116,32,98,101,32,99,111
+ DB 110,115,116,97,110,116,32,101,120,112
+ DB 114,101,115,115,105,111,110,0
+_null_is:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_3_7:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,7
+CALL __lt
+OR EAX,EAX
+JNE _3_9
+JMP _3_6
+_3_9:
+JMP _3_8
+_3_5:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+INC EAX
+MOV [EBX],EAX
+JMP _3_7
+_3_8:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+SHL EAX,1
+SHL EAX,1
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+JMP _3_5
+_3_6:
+MOV ESP,EBP
+POP EBP
+RET
+_expressi:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-32
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _level1
+ADD ESP,4
+OR EAX,EAX
+JNE _3_12
+JMP _3_11
+_3_12:
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_11:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-32]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-32]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_test:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-36
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_15
+JMP _3_14
+_3_15:
+MOV EAX,_3_13+0
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+_3_14:
+_3_16:
+LEA EAX,[EBP-32]
+PUSH EAX
+LEA EAX,[EBP-36]
+PUSH EAX
+MOV CL,2
+CALL _setstage
+ADD ESP,8
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,1
+CALL _level1
+ADD ESP,4
+OR EAX,EAX
+JNE _3_19
+JMP _3_18
+_3_19:
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_18:
+MOV EAX,_3_13+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_21
+JMP _3_20
+_3_21:
+LEA EAX,[EBP-32]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-36]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+JMP _3_22
+_3_20:
+JMP _3_17
+_3_22:
+JMP _3_16
+_3_17:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_24
+JMP _3_23
+_3_24:
+MOV EAX,_3_13+4
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+_3_23:
+LEA EAX,[EBP-28]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_26
+JMP _3_25
+_3_26:
+LEA EAX,[EBP-32]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+LEA EAX,[EBP-28]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_28
+JMP _3_27
+_3_28:
+MOV ESP,EBP
+POP EBP
+RET
+_3_27:
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_3_25:
+LEA EAX,[EBP-28]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_30
+JMP _3_29
+_3_30:
+LEA EAX,[EBP-28]
+MOV EBX,20
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+JMP _3_33
+_3_34:
+_3_35:
+MOV EAX,19
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,3
+CALL _zerojump
+ADD ESP,12
+JMP _3_32
+_3_36:
+_3_37:
+MOV EAX,54
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,3
+CALL _zerojump
+ADD ESP,12
+JMP _3_32
+_3_38:
+MOV EAX,34
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,3
+CALL _zerojump
+ADD ESP,12
+JMP _3_32
+_3_39:
+MOV EAX,21
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,3
+CALL _zerojump
+ADD ESP,12
+JMP _3_32
+_3_40:
+LEA EAX,[EBP-28]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+JMP _3_32
+_3_41:
+MOV EAX,46
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,3
+CALL _zerojump
+ADD ESP,12
+JMP _3_32
+_3_42:
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,3
+CALL _zerojump
+ADD ESP,12
+JMP _3_32
+_3_43:
+MOV EAX,42
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,3
+CALL _zerojump
+ADD ESP,12
+JMP _3_32
+_3_44:
+MOV EAX,54
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_32
+JMP _3_32
+_3_33:
+CALL __switch
+ DD _3_34
+ DD 20
+ DD _3_35
+ DD 44
+ DD _3_36
+ DD 55
+ DD _3_37
+ DD 36
+ DD _3_38
+ DD 35
+ DD _3_39
+ DD 22
+ DD _3_40
+ DD 23
+ DD _3_41
+ DD 47
+ DD _3_42
+ DD 48
+ DD _3_43
+ DD 43
+ DD 0
+JMP _3_44
+_3_32:
+JMP _3_45
+_3_29:
+MOV EAX,54
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_45:
+LEA EAX,[EBP-32]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-36]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_3_13 DB 40,0,44,0,41,0
+_zerojump:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+POP EBP
+RET
+_level1:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-48
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+LEA EAX,[EBP-40]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV EAX,_level2
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_49
+JMP _3_48
+_3_49:
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_48:
+MOV EAX,_3_47+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_51
+JMP _3_50
+_3_51:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,57
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_52
+_3_50:
+MOV EAX,_3_47+3
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_54
+JMP _3_53
+_3_54:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,73
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_55
+_3_53:
+MOV EAX,_3_47+6
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_57
+JMP _3_56
+_3_57:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,3
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_58
+_3_56:
+MOV EAX,_3_47+9
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_60
+JMP _3_59
+_3_60:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_61
+_3_59:
+MOV EAX,_3_47+12
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_63
+JMP _3_62
+_3_63:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,69
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_64
+_3_62:
+MOV EAX,_3_47+15
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_66
+JMP _3_65
+_3_66:
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX,52
+MOV [EBX],EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,53
+MOV [EBX],EAX
+JMP _3_67
+_3_65:
+MOV EAX,_3_47+18
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_69
+JMP _3_68
+_3_69:
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX,16
+MOV [EBX],EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,17
+MOV [EBX],EAX
+JMP _3_70
+_3_68:
+MOV EAX,_3_47+21
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_72
+JMP _3_71
+_3_72:
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX,49
+MOV [EBX],EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,50
+MOV [EBX],EAX
+JMP _3_73
+_3_71:
+MOV EAX,_3_47+24
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_75
+JMP _3_74
+_3_75:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,7
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_76
+_3_74:
+MOV EAX,_3_47+28
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_78
+JMP _3_77
+_3_78:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX,6
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_79
+_3_77:
+MOV EAX,_3_47+32
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_81
+JMP _3_80
+_3_81:
+LEA EAX,[EBP-44]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_82
+_3_80:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_82:
+_3_79:
+_3_76:
+_3_73:
+_3_70:
+_3_67:
+_3_64:
+_3_61:
+_3_58:
+_3_55:
+_3_52:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_84
+JMP _3_83
+_3_84:
+XOR CL,CL
+CALL _needlval
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_83:
+LEA EAX,[EBP-40]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-40]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_86
+JMP _3_85
+_3_86:
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_88
+JMP _3_87
+_3_88:
+MOV EAX,60
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_87:
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,_level1
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,5
+CALL _down2
+ADD ESP,20
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_90
+JMP _3_89
+_3_90:
+MOV EAX,59
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_89:
+JMP _3_91
+_3_85:
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_93
+JMP _3_92
+_3_93:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+LEA EAX,[EBP-44]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-48]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,_level1
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,5
+CALL _down2
+ADD ESP,20
+JMP _3_94
+_3_92:
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _level1
+ADD ESP,4
+OR EAX,EAX
+JNE _3_96
+JMP _3_95
+_3_96:
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_95:
+_3_94:
+_3_91:
+LEA EAX,[EBP-40]
+PUSH EAX
+MOV CL,1
+CALL _store
+ADD ESP,4
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_47 DB 124,61,0,94,61,0,38,61,0,43
+ DB 61,0,45,61,0,42,61,0,47,61
+ DB 0,37,61,0,62,62,61,0,60,60
+ DB 61,0,61,0
+_level2:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-76
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+LEA EAX,[EBP-56]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+LEA EAX,[EBP-60]
+PUSH EAX
+MOV EAX,_level3
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+MOV EAX,_3_97+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _3_99
+JMP _3_98
+_3_99:
+LEA EAX,[EBP-60]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_98:
+LEA EAX,[EBP-60]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,54
+PUSH EAX
+LEA EAX,[EBP-64]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _dropout
+ADD ESP,16
+MOV EAX,_level2
+PUSH EAX
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+OR EAX,EAX
+JNE _3_101
+JMP _3_100
+_3_101:
+LEA EAX,[EBP-28]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+JMP _3_102
+_3_100:
+LEA EAX,[EBP-28]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_104
+JMP _3_103
+_3_104:
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP-28]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_103:
+_3_102:
+MOV EAX,_3_97+2
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-68]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-64]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,_level2
+PUSH EAX
+LEA EAX,[EBP-56]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+OR EAX,EAX
+JNE _3_106
+JMP _3_105
+_3_106:
+LEA EAX,[EBP-56]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+JMP _3_107
+_3_105:
+LEA EAX,[EBP-56]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_109
+JMP _3_108
+_3_109:
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP-56]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_108:
+_3_107:
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-68]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-28]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_113
+JMP _3_111
+_3_113:
+LEA EAX,[EBP-56]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_114
+JMP _3_111
+_3_114:
+MOV EAX,1
+JMP _3_112
+_3_111:
+XOR EAX,EAX
+_3_112:
+OR EAX,EAX
+JNE _3_115
+JMP _3_110
+_3_115:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_116
+_3_110:
+LEA EAX,[EBP-56]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_118
+JMP _3_117
+_3_118:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-28]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-28]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-28]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+JMP _3_119
+_3_117:
+LEA EAX,[EBP-28]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_123
+JMP _3_121
+_3_123:
+LEA EAX,[EBP-28]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-56]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __eq
+OR EAX,EAX
+JE _3_124
+JMP _3_121
+_3_124:
+XOR EAX,EAX
+JMP _3_122
+_3_121:
+MOV EAX,1
+_3_122:
+OR EAX,EAX
+JNE _3_125
+JMP _3_120
+_3_125:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-56]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-56]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-56]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+JMP _3_126
+_3_120:
+MOV EAX,_3_97+4
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_3_126:
+_3_119:
+_3_116:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_97 DB 63,0,58,0,109,105,115,109,97,116
+ DB 99,104,101,100,32,101,120,112,114,101
+ DB 115,115,105,111,110,115,0
+_level3:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_127+0
+PUSH EAX
+MOV EAX,19
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,_level4
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,6
+CALL _skim
+ADD ESP,24
+POP EBP
+RET
+_3_127 DB 124,124,0
+_level4:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_128+0
+PUSH EAX
+MOV EAX,54
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV EAX,_level5
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,6
+CALL _skim
+ADD ESP,24
+POP EBP
+RET
+_3_128 DB 38,38,0
+_level5:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_129+0
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,_level6
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_129 DB 124,0
+_level6:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_130+0
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV EAX,_level7
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_130 DB 94,0
+_level7:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_131+0
+PUSH EAX
+MOV EAX,2
+PUSH EAX
+MOV EAX,_level8
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_131 DB 38,0
+_level8:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_132+0
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV EAX,_level9
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_132 DB 61,61,32,33,61,0
+_level9:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_133+0
+PUSH EAX
+MOV EAX,5
+PUSH EAX
+MOV EAX,_level10
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_133 DB 60,61,32,62,61,32,60,32,62,0
+_level10:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_134+0
+PUSH EAX
+MOV EAX,9
+PUSH EAX
+MOV EAX,_level11
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_134 DB 62,62,32,60,60,0
+_level11:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_135+0
+PUSH EAX
+MOV EAX,11
+PUSH EAX
+MOV EAX,_level12
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_135 DB 43,32,45,0
+_level12:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_136+0
+PUSH EAX
+MOV EAX,13
+PUSH EAX
+MOV EAX,_level13
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _down
+ADD ESP,16
+POP EBP
+RET
+_3_136 DB 42,32,47,32,37,0
+_level13:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+MOV EAX,_3_137+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_139
+JMP _3_138
+_3_139:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level13
+ADD ESP,4
+OR EAX,EAX
+JE _3_141
+JMP _3_140
+_3_141:
+XOR CL,CL
+CALL _needlval
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_140:
+MOV EAX,68
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,3
+CALL _step
+ADD ESP,12
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_138:
+MOV EAX,_3_137+3
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_144
+JMP _3_143
+_3_144:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level13
+ADD ESP,4
+OR EAX,EAX
+JE _3_146
+JMP _3_145
+_3_146:
+XOR CL,CL
+CALL _needlval
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_145:
+MOV EAX,65
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,3
+CALL _step
+ADD ESP,12
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_143:
+MOV EAX,_3_137+6
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_149
+JMP _3_148
+_3_149:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level13
+ADD ESP,4
+OR EAX,EAX
+JNE _3_151
+JMP _3_150
+_3_151:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_150:
+MOV EAX,13
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+NOT EAX
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_148:
+MOV EAX,_3_137+8
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_154
+JMP _3_153
+_3_154:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level13
+ADD ESP,4
+OR EAX,EAX
+JNE _3_156
+JMP _3_155
+_3_156:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_155:
+MOV EAX,45
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+CALL __lneg
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_153:
+MOV EAX,_3_137+10
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_159
+JMP _3_158
+_3_159:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level13
+ADD ESP,4
+OR EAX,EAX
+JNE _3_161
+JMP _3_160
+_3_161:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_160:
+MOV EAX,4
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+NEG EAX
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_158:
+MOV EAX,_3_137+12
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_164
+JMP _3_163
+_3_164:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level13
+ADD ESP,4
+OR EAX,EAX
+JNE _3_166
+JMP _3_165
+_3_166:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_165:
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_168
+JMP _3_167
+_3_168:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+JMP _3_169
+_3_167:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,16
+MOV [EBX],EAX
+_3_169:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_3_163:
+MOV EAX,_3_137+14
+PUSH EAX
+MOV EAX,6
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _3_172
+JMP _3_171
+_3_172:
+ADD ESP,-24
+MOV EAX,_3_137+21
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_174
+JMP _3_173
+_3_174:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+JMP _3_175
+_3_173:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_3_175:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV EAX,_3_137+23
+PUSH EAX
+MOV EAX,8
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _3_177
+JMP _3_176
+_3_177:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX,4
+MOV [EBX],EAX
+_3_176:
+MOV EAX,_3_137+32
+PUSH EAX
+MOV EAX,3
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _3_179
+JMP _3_178
+_3_179:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX,4
+MOV [EBX],EAX
+JMP _3_180
+_3_178:
+MOV EAX,_3_137+36
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _amatch
+ADD ESP,8
+OR EAX,EAX
+JNE _3_182
+JMP _3_181
+_3_182:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+_3_181:
+_3_180:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_184
+JMP _3_183
+_3_184:
+MOV EAX,_3_137+41
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_186
+JMP _3_185
+_3_186:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX,4
+MOV [EBX],EAX
+_3_185:
+JMP _3_187
+_3_183:
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JNE _3_193
+JMP _3_189
+_3_193:
+LEA EAX,[EBP-20]
+PUSH EAX
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _findloc
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JE _3_194
+JMP _3_190
+_3_194:
+LEA EAX,[EBP-20]
+PUSH EAX
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _findglb
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JE _3_195
+JMP _3_190
+_3_195:
+XOR EAX,EAX
+JMP _3_191
+_3_190:
+MOV EAX,1
+_3_191:
+OR EAX,EAX
+JNE _3_196
+JMP _3_189
+_3_196:
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,4
+CALL __ne
+OR EAX,EAX
+JNE _3_197
+JMP _3_189
+_3_197:
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __ne
+OR EAX,EAX
+JNE _3_198
+JMP _3_189
+_3_198:
+MOV EAX,1
+JMP _3_192
+_3_189:
+XOR EAX,EAX
+_3_192:
+OR EAX,EAX
+JNE _3_199
+JMP _3_188
+_3_199:
+LEA EAX,[EBP-12]
+PUSH EAX
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,3
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _getint
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+JMP _3_200
+_3_188:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_202
+JMP _3_201
+_3_202:
+MOV EAX,_3_137+43
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+_3_201:
+_3_200:
+_3_187:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_204
+JMP _3_203
+_3_204:
+MOV EAX,_3_137+66
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+_3_203:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,16
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_171:
+MOV EAX,_3_137+68
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_207
+JMP _3_206
+_3_207:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level13
+ADD ESP,4
+OR EAX,EAX
+JE _3_209
+JMP _3_208
+_3_209:
+MOV EAX,_3_137+70
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_208:
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_211
+JMP _3_210
+_3_211:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_210:
+MOV EAX,25
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_206:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level14
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+MOV EAX,_3_137+86
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_214
+JMP _3_213
+_3_214:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_216
+JMP _3_215
+_3_216:
+XOR CL,CL
+CALL _needlval
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_215:
+MOV EAX,68
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,65
+PUSH EAX
+MOV CL,3
+CALL _step
+ADD ESP,12
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_213:
+MOV EAX,_3_137+89
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_219
+JMP _3_218
+_3_219:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_221
+JMP _3_220
+_3_221:
+XOR CL,CL
+CALL _needlval
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_220:
+MOV EAX,65
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,68
+PUSH EAX
+MOV CL,3
+CALL _step
+ADD ESP,12
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_218:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_222:
+_3_217:
+_3_212:
+_3_205:
+_3_170:
+_3_162:
+_3_157:
+_3_152:
+_3_147:
+_3_142:
+MOV ESP,EBP
+POP EBP
+RET
+_3_137 DB 43,43,0,45,45,0,126,0,33,0
+ DB 45,0,42,0,115,105,122,101,111,102
+ DB 0,40,0,117,110,115,105,103,110,101
+ DB 100,0,105,110,116,0,99,104,97,114
+ DB 0,42,0,109,117,115,116,32,98,101
+ DB 32,111,98,106,101,99,116,32,111,114
+ DB 32,116,121,112,101,0,41,0,38,0
+ DB 105,108,108,101,103,97,108,32,97,100
+ DB 100,114,101,115,115,0,43,43,0,45
+ DB 45,0
+_level14:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-24
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _primary
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-16]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+XOR CL,CL
+CALL _blanks
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,91
+CALL __eq
+OR EAX,EAX
+JE _3_227
+JMP _3_225
+_3_227:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,40
+CALL __eq
+OR EAX,EAX
+JE _3_228
+JMP _3_225
+_3_228:
+XOR EAX,EAX
+JMP _3_226
+_3_225:
+MOV EAX,1
+_3_226:
+OR EAX,EAX
+JNE _3_229
+JMP _3_224
+_3_229:
+ADD ESP,-28
+LEA EAX,[EBP-52]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+_3_230:
+MOV EAX,_3_223+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_233
+JMP _3_232
+_3_233:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_235
+JMP _3_234
+_3_235:
+MOV EAX,_3_223+2
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+XOR CL,CL
+CALL _skip
+MOV EAX,_3_223+18
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_234:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_237
+JMP _3_236
+_3_237:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_239
+JMP _3_238
+_3_239:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_238:
+JMP _3_240
+_3_236:
+MOV EAX,_3_223+20
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_3_240:
+LEA EAX,[EBP-20]
+PUSH EAX
+LEA EAX,[EBP-24]
+PUSH EAX
+MOV CL,2
+CALL _setstage
+ADD ESP,8
+LEA EAX,[EBP-52]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+XOR EAX,EAX
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,_level1
+PUSH EAX
+LEA EAX,[EBP-52]
+PUSH EAX
+LEA EAX,[EBP-52]
+PUSH EAX
+MOV CL,5
+CALL _down2
+ADD ESP,20
+MOV EAX,_3_223+36
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+LEA EAX,[EBP-52]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_242
+JMP _3_241
+_3_242:
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+LEA EAX,[EBP-52]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_244
+JMP _3_243
+_3_244:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,4
+CALL __eq
+OR EAX,EAX
+JNE _3_246
+JMP _3_245
+_3_246:
+MOV EAX,110
+PUSH EAX
+LEA EAX,[EBP-52]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_247
+_3_245:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_249
+JMP _3_248
+_3_249:
+MOV EAX,110
+PUSH EAX
+LEA EAX,[EBP-52]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_250
+_3_248:
+MOV EAX,110
+PUSH EAX
+LEA EAX,[EBP-52]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_250:
+_3_247:
+MOV EAX,1
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_243:
+JMP _3_251
+_3_241:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,4
+CALL __eq
+OR EAX,EAX
+JNE _3_253
+JMP _3_252
+_3_253:
+MOV EAX,14
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,14
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_254
+_3_252:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_256
+JMP _3_255
+_3_256:
+MOV EAX,14
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_255:
+_3_254:
+MOV EAX,1
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_251:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+JMP _3_257
+_3_232:
+MOV EAX,_3_223+38
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_259
+JMP _3_258
+_3_259:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_261
+JMP _3_260
+_3_261:
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _callfunc
+ADD ESP,4
+JMP _3_262
+_3_260:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,4
+CALL __ne
+OR EAX,EAX
+JNE _3_264
+JMP _3_263
+_3_264:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_268
+JMP _3_266
+_3_268:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+CALL __lneg
+OR EAX,EAX
+JNE _3_269
+JMP _3_266
+_3_269:
+MOV EAX,1
+JMP _3_267
+_3_266:
+XOR EAX,EAX
+_3_267:
+OR EAX,EAX
+JNE _3_270
+JMP _3_265
+_3_270:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_265:
+XOR EAX,EAX
+PUSH EAX
+MOV CL,1
+CALL _callfunc
+ADD ESP,4
+JMP _3_271
+_3_263:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _callfunc
+ADD ESP,4
+_3_271:
+_3_262:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+JMP _3_272
+_3_258:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_272:
+_3_257:
+JMP _3_230
+_3_231:
+ADD ESP,28
+_3_224:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_276
+JMP _3_274
+_3_276:
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,4
+CALL __eq
+OR EAX,EAX
+JNE _3_277
+JMP _3_274
+_3_277:
+MOV EAX,1
+JMP _3_275
+_3_274:
+XOR EAX,EAX
+_3_275:
+OR EAX,EAX
+JNE _3_278
+JMP _3_273
+_3_278:
+MOV EAX,25
+PUSH EAX
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_273:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_223 DB 91,0,99,97,110,39,116,32,115,117
+ DB 98,115,99,114,105,112,116,0,93,0
+ DB 99,97,110,39,116,32,115,117,98,115
+ DB 99,114,105,112,116,0,93,0,40,0
+_primary:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-20
+MOV EAX,_3_279+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_281
+JMP _3_280
+_3_281:
+_3_282:
+LEA EAX,[EBP-20]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _level1
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+MOV EAX,_3_279+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_284
+JMP _3_283
+_3_284:
+JMP _3_282
+_3_283:
+MOV EAX,_3_279+4
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+LEA EAX,[EBP-20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_280:
+XOR EAX,EAX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,14
+PUSH EAX
+MOV CL,3
+CALL _putint
+ADD ESP,12
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,1
+CALL _symname
+ADD ESP,4
+OR EAX,EAX
+JNE _3_286
+JMP _3_285
+_3_286:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,1
+CALL _findloc
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_288
+JMP _3_287
+_3_288:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+OR EAX,EAX
+JE _3_290
+JMP _3_289
+_3_290:
+XOR CL,CL
+CALL _experr
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_289:
+MOV EAX,58
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,5
+ADD EAX,EBX
+MOV EBX,2
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,2
+CALL _getint
+ADD ESP,8
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_292
+JMP _3_291
+_3_292:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_291:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _3_294
+JMP _3_293
+_3_294:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,17
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+_3_293:
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_3_287:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV CL,1
+CALL _findglb
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_296
+JMP _3_295
+_3_296:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,4
+CALL __ne
+OR EAX,EAX
+JNE _3_298
+JMP _3_297
+_3_298:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_300
+JMP _3_299
+_3_300:
+MOV EAX,25
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_299:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _3_302
+JMP _3_301
+_3_302:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+POP EBX
+MOV [EBX],EAX
+_3_301:
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_3_297:
+JMP _3_303
+_3_295:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-16]
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV EAX,16
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV EAX,_glbptr
+PUSH EAX
+MOV EAX,4
+PUSH EAX
+MOV CL,7
+CALL _addsym
+ADD ESP,28
+POP EBX
+MOV [EBX],EAX
+_3_303:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_285:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _constant
+ADD ESP,4
+OR EAX,EAX
+JE _3_305
+JMP _3_304
+_3_305:
+XOR CL,CL
+CALL _experr
+_3_304:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_279 DB 40,0,44,0,41,0
+_experr:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,_3_306+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+MOV EAX,108
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+XOR CL,CL
+CALL _skip
+POP EBP
+RET
+_3_306 DB 105,110,118,97,108,105,100,32,101,120
+ DB 112,114,101,115,115,105,111,110,0
+_callfunc:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-12
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+XOR CL,CL
+CALL _blanks
+_3_308:
+MOV EAX,[_lptr]
+PUSH EAX
+MOV EAX,_3_307+0
+PUSH EAX
+MOV CL,2
+CALL _streq
+ADD ESP,8
+OR EAX,EAX
+JE _3_310
+JMP _3_309
+_3_310:
+XOR CL,CL
+CALL _endst
+OR EAX,EAX
+JNE _3_312
+JMP _3_311
+_3_312:
+JMP _3_309
+_3_311:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_314
+JMP _3_313
+_3_314:
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP-12]
+PUSH EAX
+MOV CL,2
+CALL _expressi
+ADD ESP,8
+MOV EAX,60
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_315
+_3_313:
+MOV EAX,60
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP-12]
+PUSH EAX
+MOV CL,2
+CALL _expressi
+ADD ESP,8
+MOV EAX,71
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_315:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+MOV EAX,_3_307+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _3_317
+JMP _3_316
+_3_317:
+JMP _3_309
+_3_316:
+JMP _3_308
+_3_309:
+MOV EAX,_3_307+4
+PUSH EAX
+MOV CL,1
+CALL _need
+ADD ESP,4
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_321
+JMP _3_319
+_3_321:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,11
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,_3_307+6
+PUSH EAX
+MOV CL,2
+CALL _streq
+ADD ESP,8
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JNE _3_322
+JMP _3_319
+_3_322:
+MOV EAX,1
+JMP _3_320
+_3_319:
+XOR EAX,EAX
+_3_320:
+OR EAX,EAX
+JNE _3_323
+JMP _3_318
+_3_323:
+MOV EAX,5
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_318:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_325
+JMP _3_324
+_3_325:
+MOV EAX,9
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_326
+_3_324:
+MOV EAX,8
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_326:
+MOV EAX,2
+PUSH EAX
+MOV EAX,[_csp]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV ESP,EBP
+POP EBP
+RET
+_3_307 DB 41,0,44,0,41,0,67,67,65,82
+ DB 71,67,0
+_fdouble:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JE _3_333
+JMP _3_329
+_3_333:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,69
+CALL __eq
+OR EAX,EAX
+JE _3_334
+JMP _3_329
+_3_334:
+XOR EAX,EAX
+JMP _3_330
+_3_329:
+MOV EAX,1
+_3_330:
+OR EAX,EAX
+JNE _3_335
+JMP _3_331
+_3_335:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JNE _3_336
+JMP _3_331
+_3_336:
+MOV EAX,1
+JMP _3_332
+_3_331:
+XOR EAX,EAX
+_3_332:
+OR EAX,EAX
+JNE _3_337
+JMP _3_328
+_3_337:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+JMP _3_340
+_3_341:
+_3_342:
+XOR EAX,EAX
+POP EBP
+RET
+_3_343:
+MOV EAX,1
+POP EBP
+RET
+_3_344:
+MOV EAX,2
+POP EBP
+RET
+JMP _3_339
+_3_340:
+CALL __switch
+ DD _3_342
+ DD 1
+ DD _3_343
+ DD 2
+ DD _3_344
+ DD 4
+ DD 0
+JMP _3_341
+_3_339:
+_3_328:
+XOR EAX,EAX
+POP EBP
+RET
+_step:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_348
+JMP _3_346
+_3_348:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+JMP _3_347
+_3_346:
+MOV EAX,1
+_3_347:
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _store
+ADD ESP,4
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_350
+JMP _3_349
+_3_350:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_353
+JMP _3_351
+_3_353:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+JMP _3_352
+_3_351:
+MOV EAX,1
+_3_352:
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_349:
+POP EBP
+RET
+_store:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_356
+JMP _3_355
+_3_356:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JNE _3_358
+JMP _3_357
+_3_358:
+MOV EAX,62
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_359
+_3_357:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_361
+JMP _3_360
+_3_361:
+MOV EAX,64
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_362
+_3_360:
+MOV EAX,115
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_362:
+_3_359:
+JMP _3_363
+_3_355:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _3_365
+JMP _3_364
+_3_365:
+MOV EAX,114
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_366
+_3_364:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JNE _3_368
+JMP _3_367
+_3_368:
+MOV EAX,61
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_369
+_3_367:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_371
+JMP _3_370
+_3_371:
+MOV EAX,63
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_372
+_3_370:
+MOV EAX,114
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_372:
+_3_369:
+_3_366:
+_3_363:
+MOV ESP,EBP
+POP EBP
+RET
+_fetch:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_375
+JMP _3_374
+_3_375:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,4
+CALL __eq
+OR EAX,EAX
+JNE _3_377
+JMP _3_376
+_3_377:
+MOV EAX,109
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_378
+_3_376:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_380
+JMP _3_379
+_3_380:
+MOV EAX,32
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_381
+_3_379:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,1
+AND EAX,EBX
+OR EAX,EAX
+JNE _3_383
+JMP _3_382
+_3_383:
+MOV EAX,29
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_384
+_3_382:
+MOV EAX,28
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_384:
+_3_381:
+_3_378:
+JMP _3_385
+_3_374:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,3
+CALL __eq
+OR EAX,EAX
+JNE _3_387
+JMP _3_386
+_3_387:
+MOV EAX,107
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_388
+_3_386:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,4
+CALL __eq
+OR EAX,EAX
+JNE _3_390
+JMP _3_389
+_3_390:
+MOV EAX,107
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_391
+_3_389:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_393
+JMP _3_392
+_3_393:
+MOV EAX,30
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_394
+_3_392:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,1
+AND EAX,EBX
+OR EAX,EAX
+JNE _3_396
+JMP _3_395
+_3_396:
+MOV EAX,27
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_397
+_3_395:
+MOV EAX,26
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_397:
+_3_394:
+_3_391:
+_3_388:
+_3_385:
+MOV ESP,EBP
+POP EBP
+RET
+_constant:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+MOV CL,1
+CALL _number
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_400
+JMP _3_399
+_3_400:
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_401
+_3_399:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+MOV CL,1
+CALL _chrcon
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_403
+JMP _3_402
+_3_403:
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_404
+_3_402:
+LEA EAX,[EBP-4]
+PUSH EAX
+MOV CL,1
+CALL _string
+ADD ESP,4
+OR EAX,EAX
+JNE _3_406
+JMP _3_405
+_3_406:
+MOV EAX,24
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_407
+_3_405:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_407:
+_3_404:
+_3_401:
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_number:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+_3_409:
+MOV EAX,_3_408+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_412
+JMP _3_411
+_3_412:
+JMP _3_413
+_3_411:
+MOV EAX,_3_408+2
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JNE _3_415
+JMP _3_414
+_3_415:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX,1
+MOV [EBX],EAX
+JMP _3_416
+_3_414:
+JMP _3_410
+_3_416:
+_3_413:
+JMP _3_409
+_3_410:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _isdigit
+ADD ESP,4
+OR EAX,EAX
+JE _3_418
+JMP _3_417
+_3_418:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_417:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,48
+CALL __eq
+OR EAX,EAX
+JNE _3_420
+JMP _3_419
+_3_420:
+_3_421:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,48
+CALL __eq
+OR EAX,EAX
+JNE _3_423
+JMP _3_422
+_3_423:
+XOR CL,CL
+CALL _inbyte
+JMP _3_421
+_3_422:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,88
+CALL __eq
+OR EAX,EAX
+JNE _3_425
+JMP _3_424
+_3_425:
+XOR CL,CL
+CALL _inbyte
+_3_426:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _isxdigit
+ADD ESP,4
+OR EAX,EAX
+JNE _3_428
+JMP _3_427
+_3_428:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _isdigit
+ADD ESP,4
+OR EAX,EAX
+JNE _3_430
+JMP _3_429
+_3_430:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,16
+IMUL EBX
+PUSH EAX
+XOR CL,CL
+CALL _inbyte
+MOV EBX,EAX
+MOV EAX,48
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+JMP _3_431
+_3_429:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,16
+IMUL EBX
+MOV EBX,10
+ADD EAX,EBX
+PUSH EAX
+XOR CL,CL
+CALL _inbyte
+PUSH EAX
+MOV CL,1
+CALL _toupper
+ADD ESP,4
+MOV EBX,EAX
+MOV EAX,65
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+_3_431:
+JMP _3_426
+_3_427:
+JMP _3_432
+_3_424:
+_3_433:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,48
+CALL __ge
+OR EAX,EAX
+JNE _3_437
+JMP _3_435
+_3_437:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,55
+CALL __le
+OR EAX,EAX
+JNE _3_438
+JMP _3_435
+_3_438:
+MOV EAX,1
+JMP _3_436
+_3_435:
+XOR EAX,EAX
+_3_436:
+OR EAX,EAX
+JNE _3_439
+JMP _3_434
+_3_439:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,8
+IMUL EBX
+PUSH EAX
+XOR CL,CL
+CALL _inbyte
+MOV EBX,EAX
+MOV EAX,48
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+JMP _3_433
+_3_434:
+_3_432:
+JMP _3_440
+_3_419:
+_3_441:
+MOV EAX,[_ch]
+PUSH EAX
+MOV CL,1
+CALL _isdigit
+ADD ESP,4
+OR EAX,EAX
+JNE _3_443
+JMP _3_442
+_3_443:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,10
+IMUL EBX
+PUSH EAX
+XOR CL,CL
+CALL _inbyte
+MOV EBX,EAX
+MOV EAX,48
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+JMP _3_441
+_3_442:
+_3_440:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_445
+JMP _3_444
+_3_445:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+NEG EAX
+POP EBX
+MOV [EBX],EAX
+MOV EAX,16
+MOV ESP,EBP
+POP EBP
+RET
+_3_444:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JL _3_447
+JMP _3_446
+_3_447:
+MOV EAX,17
+MOV ESP,EBP
+POP EBP
+RET
+_3_446:
+MOV EAX,16
+MOV ESP,EBP
+POP EBP
+RET
+_3_448:
+MOV ESP,EBP
+POP EBP
+RET
+_3_408 DB 43,0,45,0
+_chrcon:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+MOV EAX,_3_449+0
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _3_451
+JMP _3_450
+_3_451:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_450:
+_3_452:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,39
+CALL __ne
+OR EAX,EAX
+JNE _3_454
+JMP _3_453
+_3_454:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,8
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+XOR CL,CL
+CALL _litchar
+MOV EBX,EAX
+MOV EAX,255
+AND EAX,EBX
+POP EBX
+ADD EAX,EBX
+POP EBX
+MOV [EBX],EAX
+JMP _3_452
+_3_453:
+XOR CL,CL
+CALL _gch
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+MOV EAX,16
+MOV ESP,EBP
+POP EBP
+RET
+_3_449 DB 39,0
+_string:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+MOV EAX,_quote
+PUSH EAX
+MOV CL,1
+CALL _match
+ADD ESP,4
+OR EAX,EAX
+JE _3_457
+JMP _3_456
+_3_457:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_456:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_litptr]
+POP EBX
+MOV [EBX],EAX
+_3_458:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,34
+CALL __ne
+OR EAX,EAX
+JNE _3_460
+JMP _3_459
+_3_460:
+MOV EAX,[_ch]
+OR EAX,EAX
+JE _3_462
+JMP _3_461
+_3_462:
+JMP _3_459
+_3_461:
+XOR CL,CL
+CALL _litchar
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _stowlit
+ADD ESP,8
+JMP _3_458
+_3_459:
+XOR CL,CL
+CALL _gch
+MOV EAX,[_litq]
+PUSH EAX
+MOV EAX,[_litptr]
+INC EAX
+MOV DWORD [_litptr],EAX
+DEC EAX
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],AL
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_stowlit:
+PUSH EBP
+MOV EBP,ESP
+MOV EAX,[_litptr]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,2999
+CALL __ge
+OR EAX,EAX
+JNE _3_465
+JMP _3_464
+_3_465:
+MOV EAX,_3_463+0
+PUSH EAX
+MOV CL,1
+CALL _error
+ADD ESP,4
+MOV EAX,7
+PUSH EAX
+MOV CL,1
+CALL _OS_exit
+ADD ESP,4
+_3_464:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,[_litq]
+PUSH EAX
+MOV EAX,[_litptr]
+POP EBX
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _putint
+ADD ESP,12
+MOV EAX,[_litptr]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV DWORD [_litptr],EAX
+POP EBP
+RET
+_3_463 DB 108,105,116,101,114,97,108,32,113,117
+ DB 101,117,101,32,111,118,101,114,102,108
+ DB 111,119,0
+_litchar:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-8
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,92
+CALL __ne
+OR EAX,EAX
+JE _3_470
+JMP _3_468
+_3_470:
+MOV EAX,[_nch]
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JE _3_471
+JMP _3_468
+_3_471:
+XOR EAX,EAX
+JMP _3_469
+_3_468:
+MOV EAX,1
+_3_469:
+OR EAX,EAX
+JNE _3_472
+JMP _3_467
+_3_472:
+XOR CL,CL
+CALL _gch
+MOV ESP,EBP
+POP EBP
+RET
+_3_467:
+XOR CL,CL
+CALL _gch
+MOV EAX,[_ch]
+JMP _3_475
+_3_476:
+XOR CL,CL
+CALL _gch
+MOV EAX,10
+MOV ESP,EBP
+POP EBP
+RET
+_3_477:
+XOR CL,CL
+CALL _gch
+MOV EAX,13
+MOV ESP,EBP
+POP EBP
+RET
+_3_478:
+XOR CL,CL
+CALL _gch
+MOV EAX,9
+MOV ESP,EBP
+POP EBP
+RET
+_3_479:
+XOR CL,CL
+CALL _gch
+MOV EAX,8
+MOV ESP,EBP
+POP EBP
+RET
+_3_480:
+XOR CL,CL
+CALL _gch
+MOV EAX,12
+MOV ESP,EBP
+POP EBP
+RET
+JMP _3_474
+_3_475:
+CALL __switch
+ DD _3_476
+ DD 110
+ DD _3_477
+ DD 114
+ DD _3_478
+ DD 116
+ DD _3_479
+ DD 98
+ DD _3_480
+ DD 102
+ DD 0
+_3_474:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX,3
+MOV [EBX],EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_3_481:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+DEC EAX
+MOV [EBX],EAX
+INC EAX
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __gt
+OR EAX,EAX
+JNE _3_485
+JMP _3_483
+_3_485:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,48
+CALL __ge
+OR EAX,EAX
+JNE _3_486
+JMP _3_483
+_3_486:
+MOV EAX,[_ch]
+MOV EBX,EAX
+MOV EAX,55
+CALL __le
+OR EAX,EAX
+JNE _3_487
+JMP _3_483
+_3_487:
+MOV EAX,1
+JMP _3_484
+_3_483:
+XOR EAX,EAX
+_3_484:
+OR EAX,EAX
+JNE _3_488
+JMP _3_482
+_3_488:
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,3
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+XOR CL,CL
+CALL _gch
+POP EBX
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,48
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBX
+MOV [EBX],EAX
+JMP _3_481
+_3_482:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_490
+JMP _3_489
+_3_490:
+XOR CL,CL
+CALL _gch
+MOV ESP,EBP
+POP EBP
+RET
+_3_489:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_491:
+MOV ESP,EBP
+POP EBP
+RET
+_skim:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-12
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+_3_493:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+28]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _nextop
+ADD ESP,4
+OR EAX,EAX
+JNE _3_496
+JMP _3_495
+_3_496:
+MOV EAX,[_opsize]
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_498
+JMP _3_497
+_3_498:
+LEA EAX,[EBP-8]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+_3_497:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _dropout
+ADD ESP,16
+JMP _3_499
+_3_495:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_501
+JMP _3_500
+_3_501:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,4
+CALL _dropout
+ADD ESP,16
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,40
+PUSH EAX
+LEA EAX,[EBP-12]
+PUSH EAX
+XOR CL,CL
+CALL _getlabel
+POP EBX
+MOV [EBX],EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,41
+PUSH EAX
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+POP EBX
+MOV [EBX],EAX
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_500:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_502:
+_3_499:
+JMP _3_493
+_3_494:
+MOV ESP,EBP
+POP EBP
+RET
+_dropout:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_505
+JMP _3_504
+_3_505:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+JMP _3_506
+_3_504:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_508
+JMP _3_507
+_3_508:
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_507:
+_3_506:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+POP EBP
+RET
+_down:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _nextop
+ADD ESP,4
+OR EAX,EAX
+JE _3_511
+JMP _3_510
+_3_511:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_3_510:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_513
+JMP _3_512
+_3_513:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_512:
+_3_514:
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _nextop
+ADD ESP,4
+OR EAX,EAX
+JNE _3_517
+JMP _3_516
+_3_517:
+ADD ESP,-28
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,1
+CALL _null_is
+ADD ESP,4
+MOV EAX,[_opsize]
+PUSH EAX
+MOV CL,1
+CALL _bump
+ADD ESP,4
+MOV EAX,[_opindex]
+PUSH EAX
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+MOV DWORD [_opindex],EAX
+MOV EAX,_op
+PUSH EAX
+MOV EAX,[_opindex]
+POP EBX
+SHL EAX,1
+SHL EAX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV EAX,_op2
+PUSH EAX
+MOV EAX,[_opindex]
+POP EBX
+SHL EAX,1
+SHL EAX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP-32]
+PUSH EAX
+MOV CL,5
+CALL _down2
+ADD ESP,20
+ADD ESP,28
+JMP _3_518
+_3_516:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_3_518:
+JMP _3_514
+_3_515:
+MOV ESP,EBP
+POP EBP
+RET
+_down1:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-12
+LEA EAX,[EBP-8]
+PUSH EAX
+LEA EAX,[EBP-12]
+PUSH EAX
+MOV CL,2
+CALL _setstage
+ADD ESP,8
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XCHG EAX,EBX
+PUSH EBX
+CALL EAX
+ADD ESP,4
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_521
+JMP _3_520
+_3_521:
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+_3_520:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV ESP,EBP
+POP EBP
+RET
+_down2:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-16
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP-8]
+PUSH EAX
+MOV CL,2
+CALL _setstage
+ADD ESP,8
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_524
+JMP _3_523
+_3_524:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+OR EAX,EAX
+JNE _3_526
+JMP _3_525
+_3_526:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_525:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_528
+JMP _3_527
+_3_528:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+PUSH EAX
+MOV EAX,[_snext]
+POP EBX
+MOV [EBX],EAX
+_3_527:
+MOV EAX,33
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _fdouble
+ADD ESP,12
+POP EBX
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_529
+_3_523:
+MOV EAX,60
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,2
+CALL _down1
+ADD ESP,8
+OR EAX,EAX
+JNE _3_531
+JMP _3_530
+_3_531:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _fetch
+ADD ESP,4
+_3_530:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_533
+JMP _3_532
+_3_533:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_535
+JMP _3_534
+_3_535:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,24
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP-8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+_3_534:
+MOV EAX,[_csp]
+MOV EBX,4
+ADD EAX,EBX
+MOV DWORD [_csp],EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JNE _3_537
+JMP _3_536
+_3_537:
+MOV EAX,110
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _fdouble
+ADD ESP,12
+POP EBX
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+JMP _3_538
+_3_536:
+MOV EAX,51
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,108
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _fdouble
+ADD ESP,12
+POP EBX
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_538:
+JMP _3_539
+_3_532:
+MOV EAX,59
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP-16]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _fdouble
+ADD ESP,12
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_541
+JMP _3_540
+_3_541:
+MOV EAX,14
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __gt
+OR EAX,EAX
+JNE _3_543
+JMP _3_542
+_3_543:
+MOV EAX,14
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_542:
+_3_540:
+LEA EAX,[EBP-16]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _fdouble
+ADD ESP,12
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_545
+JMP _3_544
+_3_545:
+MOV EAX,15
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP-16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __gt
+OR EAX,EAX
+JNE _3_547
+JMP _3_546
+_3_547:
+MOV EAX,15
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_546:
+_3_544:
+_3_539:
+_3_529:
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_549
+JMP _3_548
+_3_549:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _nosign
+ADD ESP,4
+OR EAX,EAX
+JE _3_553
+JMP _3_551
+_3_553:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,1
+CALL _nosign
+ADD ESP,4
+OR EAX,EAX
+JE _3_554
+JMP _3_551
+_3_554:
+XOR EAX,EAX
+JMP _3_552
+_3_551:
+MOV EAX,1
+_3_552:
+OR EAX,EAX
+JNE _3_555
+JMP _3_550
+_3_555:
+LEA EAX,[EBP+24]
+PUSH EAX
+LEA EAX,[EBP+20]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+_3_550:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+AND EAX,EBX
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_557
+JMP _3_556
+_3_557:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,16
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _calc
+ADD ESP,12
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _clearsta
+ADD ESP,8
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,17
+CALL __eq
+OR EAX,EAX
+JNE _3_559
+JMP _3_558
+_3_559:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX,17
+MOV [EBX],EAX
+_3_558:
+JMP _3_560
+_3_556:
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,69
+CALL __eq
+OR EAX,EAX
+JNE _3_564
+JMP _3_562
+_3_564:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_565
+JMP _3_562
+_3_565:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,2
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+MOV EBX,EAX
+MOV EAX,2
+CALL __eq
+OR EAX,EAX
+JNE _3_566
+JMP _3_562
+_3_566:
+MOV EAX,1
+JMP _3_563
+_3_562:
+XOR EAX,EAX
+_3_563:
+OR EAX,EAX
+JNE _3_567
+JMP _3_561
+_3_567:
+MOV EAX,70
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,31
+PUSH EAX
+MOV EAX,1
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+MOV EAX,7
+PUSH EAX
+XOR EAX,EAX
+PUSH EAX
+MOV CL,2
+CALL _gen
+ADD ESP,8
+_3_561:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,20
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+_3_560:
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,69
+CALL __eq
+OR EAX,EAX
+JE _3_571
+JMP _3_569
+_3_571:
+LEA EAX,[EBP+24]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,1
+CALL __eq
+OR EAX,EAX
+JE _3_572
+JMP _3_569
+_3_572:
+XOR EAX,EAX
+JMP _3_570
+_3_569:
+MOV EAX,1
+_3_570:
+OR EAX,EAX
+JNE _3_573
+JMP _3_568
+_3_573:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_577
+JMP _3_575
+_3_577:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_578
+JMP _3_575
+_3_578:
+MOV EAX,1
+JMP _3_576
+_3_575:
+XOR EAX,EAX
+_3_576:
+OR EAX,EAX
+JNE _3_579
+JMP _3_574
+_3_579:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+XOR EAX,EAX
+MOV [EBX],EAX
+JMP _3_580
+_3_574:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JNE _3_582
+JMP _3_581
+_3_582:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,4
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+_3_581:
+_3_580:
+_3_568:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+XOR EAX,EAX
+CALL __eq
+OR EAX,EAX
+JE _3_588
+JMP _3_584
+_3_588:
+LEA EAX,[EBP-12]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_589
+JMP _3_585
+_3_589:
+LEA EAX,[EBP-12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,1
+AND EAX,EBX
+OR EAX,EAX
+JNE _3_590
+JMP _3_585
+_3_590:
+MOV EAX,1
+JMP _3_586
+_3_585:
+XOR EAX,EAX
+_3_586:
+OR EAX,EAX
+JE _3_591
+JMP _3_584
+_3_591:
+XOR EAX,EAX
+JMP _3_587
+_3_584:
+MOV EAX,1
+_3_587:
+OR EAX,EAX
+JNE _3_592
+JMP _3_583
+_3_592:
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+_3_583:
+_3_548:
+MOV ESP,EBP
+POP EBP
+RET
+_nosign:
+PUSH EBP
+MOV EBP,ESP
+ADD ESP,-4
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,8
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+OR EAX,EAX
+JE _3_599
+JMP _3_595
+_3_599:
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,12
+ADD EAX,EBX
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX,17
+CALL __eq
+OR EAX,EAX
+JE _3_600
+JMP _3_595
+_3_600:
+LEA EAX,[EBP-4]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV [EBX],EAX
+OR EAX,EAX
+JNE _3_601
+JMP _3_596
+_3_601:
+LEA EAX,[EBP-4]
+MOV EBX,EAX
+MOV EAX, [EBX]
+MOV EBX,1
+ADD EAX,EBX
+MOV EBX,EAX
+MOVSX EAX,BYTE [EBX]
+MOV EBX,EAX
+MOV EAX,1
+AND EAX,EBX
+OR EAX,EAX
+JNE _3_602
+JMP _3_596
+_3_602:
+MOV EAX,1
+JMP _3_597
+_3_596:
+XOR EAX,EAX
+_3_597:
+OR EAX,EAX
+JE _3_603
+JMP _3_595
+_3_603:
+XOR EAX,EAX
+JMP _3_598
+_3_595:
+MOV EAX,1
+_3_598:
+OR EAX,EAX
+JNE _3_604
+JMP _3_594
+_3_604:
+MOV EAX,1
+MOV ESP,EBP
+POP EBP
+RET
+_3_594:
+XOR EAX,EAX
+MOV ESP,EBP
+POP EBP
+RET
+_calc:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+JMP _3_608
+_3_609:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+ADD EAX,EBX
+POP EBP
+RET
+_3_610:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XCHG EAX,EBX
+SUB EAX,EBX
+POP EBP
+RET
+_3_611:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+IMUL EBX
+POP EBP
+RET
+_3_612:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XCHG EAX,EBX
+CDQ
+IDIV EBX
+POP EBP
+RET
+_3_613:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XCHG EAX,EBX
+CDQ
+IDIV EBX
+MOV EAX,EDX
+POP EBP
+RET
+_3_614:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __eq
+POP EBP
+RET
+_3_615:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __ne
+POP EBP
+RET
+_3_616:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __le
+POP EBP
+RET
+_3_617:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __ge
+POP EBP
+RET
+_3_618:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __lt
+POP EBP
+RET
+_3_619:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __gt
+POP EBP
+RET
+_3_620:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+AND EAX,EBX
+POP EBP
+RET
+_3_621:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+OR EAX,EBX
+POP EBP
+RET
+_3_622:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XOR EAX,EBX
+POP EBP
+RET
+_3_623:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV ECX,EAX
+MOV EAX,EBX
+SAR EAX,CL
+POP EBP
+RET
+_3_624:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MOV ECX,EAX
+MOV EAX,EBX
+SAL EAX,CL
+POP EBP
+RET
+JMP _3_607
+_3_608:
+CALL __switch
+ DD _3_609
+ DD 1
+ DD _3_610
+ DD 69
+ DD _3_611
+ DD 52
+ DD _3_612
+ DD 16
+ DD _3_613
+ DD 49
+ DD _3_614
+ DD 20
+ DD _3_615
+ DD 55
+ DD _3_616
+ DD 43
+ DD _3_617
+ DD 22
+ DD _3_618
+ DD 47
+ DD _3_619
+ DD 35
+ DD _3_620
+ DD 3
+ DD _3_621
+ DD 57
+ DD _3_622
+ DD 73
+ DD _3_623
+ DD 7
+ DD _3_624
+ DD 6
+ DD 0
+_3_607:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+MOV CL,3
+CALL _calc2
+ADD ESP,12
+POP EBP
+RET
+_calc2:
+PUSH EBP
+MOV EBP,ESP
+LEA EAX,[EBP+12]
+MOV EBX,EAX
+MOV EAX, [EBX]
+JMP _3_628
+_3_629:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+MUL EBX
+POP EBP
+RET
+_3_630:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XCHG EAX,EBX
+XOR EDX,EDX
+DIV EBX
+POP EBP
+RET
+_3_631:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+XCHG EAX,EBX
+XOR EDX,EDX
+DIV EBX
+MOV EAX,EDX
+POP EBP
+RET
+_3_632:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __ule
+POP EBP
+RET
+_3_633:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __uge
+POP EBP
+RET
+_3_634:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __ult
+POP EBP
+RET
+_3_635:
+LEA EAX,[EBP+16]
+MOV EBX,EAX
+MOV EAX, [EBX]
+PUSH EAX
+LEA EAX,[EBP+8]
+MOV EBX,EAX
+MOV EAX, [EBX]
+POP EBX
+CALL __ugt
+POP EBP
+RET
+JMP _3_627
+_3_628:
+CALL __switch
+ DD _3_629
+ DD 53
+ DD _3_630
+ DD 17
+ DD _3_631
+ DD 50
+ DD _3_632
+ DD 44
+ DD _3_633
+ DD 23
+ DD _3_634
+ DD 48
+ DD _3_635
+ DD 36
+ DD 0
+_3_627:
+XOR EAX,EAX
+POP EBP
+RET

/programs/develop/scc/OSFUNC.ASM
1,4 → 1,4
include "macros.inc"
include "MACROS.INC"
;
; OS function implementation
; SmallC for KolibriOS

/programs/develop/scc/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("SCC.ASM", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "SCC")

/programs/develop/sdk/trunk/pixlib/Tupfile.lua
0,0 → 1,2
if tup.getconfig("NO_FASM") ~= "" then return end
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B")

/programs/develop/sdk/trunk/sound/src/Tupfile.lua
0,0 → 1,7
if tup.getconfig("NO_FASM") ~= "" or (tup.getconfig("NO_MSVC") ~= "" and tup.getconfig("NO_GCC") ~= "") then return end

OBJS = tup.foreach_rule("*.asm", "fasm %f %o", "%B.obj")
if tup.getconfig("NO_GCC") == ""
then tup.rule(OBJS, "kos32-ar rcs %o %f", "sound.lib")
else tup.rule(OBJS, "link.exe /lib /out:%o %f", "sound.lib")
end

/programs/develop/str_double/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"str_double.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "str_double")

/programs/develop/tinypad/trunk/Tupfile.lua
0,0 → 1,3
if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"})
tup.rule({"tinypad.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "tinypad")

Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 5094 → Rev 5098