Subversion Repositories Kolibri OS

Rev

Rev 5697 | Rev 5706 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. //CODED by Veliant, Leency, Nable. GNU GPL licence.
  2. #ifndef INCLUDE_KOLIBRI_H
  3. #define INCLUDE_KOLIBRI_H
  4. #print "[include <kolibri.h>]\n"
  5.  
  6. #pragma option OST
  7. #pragma option ON
  8. #pragma option cri-
  9. #pragma option -CPA
  10. #initallvar 0
  11. #jumptomain FALSE
  12.  
  13. #startaddress 0
  14.  
  15. #code32 TRUE
  16.  
  17. char   os_name[8]   = {'M','E','N','U','E','T','0','1'};
  18. dword  os_version   = 0x00000001;
  19. dword  start_addr   = #______INIT______;
  20. dword  final_addr   = #______STOP______+32;
  21. dword  alloc_mem    = MEMSIZE;
  22. dword  x86esp_reg   = MEMSIZE;
  23. dword  I_Param      = #param;
  24. dword  I_Path       = #program_path;
  25. char param[4096];
  26. char program_path[4096];
  27.  
  28. #define NULL      0
  29. #define OLD      -1
  30. #define true      1
  31. #define false     0
  32.  
  33. //Events
  34.  
  35. #define evReDraw  1
  36. #define evKey     2
  37. #define evButton  3
  38. #define evDesktop 5
  39. #define evMouse   6
  40. #define evIPC     7
  41. #define evNetwork 8
  42. #define evDebug   9
  43.  
  44. #define EVENT_MOUSE case 6: mouse.get();
  45.  
  46. //Button options
  47. #define BT_DEL      0x80000000
  48. #define BT_HIDE     0x40000000
  49. #define BT_NOFRAME  0x20000000
  50.  
  51. //ASCII KEYS
  52. #define ASCII_KEY_BS    008
  53. #define ASCII_KEY_TAB   009
  54. #define ASCII_KEY_ENTER 013
  55. #define ASCII_KEY_ESC   027
  56. #define ASCII_KEY_DEL   182
  57. #define ASCII_KEY_INS   185
  58. #define ASCII_KEY_SPACE 032
  59.  
  60. #define ASCII_KEY_LEFT  176
  61. #define ASCII_KEY_RIGHT 179
  62. #define ASCII_KEY_DOWN  177
  63. #define ASCII_KEY_UP    178
  64. #define ASCII_KEY_HOME  180
  65. #define ASCII_KEY_END   181
  66. #define ASCII_KEY_PGDN  183
  67. #define ASCII_KEY_PGUP  184
  68.  
  69. //SCAN CODE KEYS
  70. #define SCAN_CODE_BS    014
  71. #define SCAN_CODE_TAB   015
  72. #define SCAN_CODE_ENTER 028
  73. #define SCAN_CODE_ESC   001
  74. #define SCAN_CODE_DEL   083
  75. #define SCAN_CODE_INS   082
  76. #define SCAN_CODE_SPACE 057
  77.            
  78. #define SCAN_CODE_LEFT  075
  79. #define SCAN_CODE_RIGHT 077
  80. #define SCAN_CODE_DOWN  080
  81. #define SCAN_CODE_UP    072
  82. #define SCAN_CODE_HOME  071
  83. #define SCAN_CODE_END   079
  84. #define SCAN_CODE_PGDN  081
  85. #define SCAN_CODE_PGUP  073
  86.  
  87. //allow event mask
  88. #define EVENT_MASK_REDRAW   000000001b
  89. #define EVENT_MASK_KEYBOARD 000000010b
  90. #define EVENT_MASK_BUTTONS  000000100b
  91. #define EVENT_MASK_DESKTOP  000010000b
  92. #define EVENT_MASK_MOUSE    000100000b
  93. #define EVENT_MASK_IPC      001000000b
  94. #define EVENT_MASK_NETWORK  010000000b
  95. #define EVENT_MASK_DEBUG    100000000b
  96.  
  97. //ARGS FUNCTION
  98. #define END_ARGS 0xFF00FF
  99. //-------------------------------------------------------------------------
  100.  
  101. #ifndef INCLUDE_SYSTEM_H
  102. #include "../lib/system.h"
  103. #endif
  104.  
  105. #ifndef INCLUDE_MOUSE_H
  106. #include "../lib/mouse.h"
  107. #endif
  108.  
  109. :struct raw_image {
  110.         dword w, h, data;
  111. };
  112.  
  113.  
  114.  
  115. //------------------------------------------------------------------------------
  116. :dword wait_event_code;
  117. inline fastcall dword WaitEvent()
  118. {
  119.         $mov eax,10
  120.         $int 0x40
  121.         wait_event_code = EAX;
  122.         //if(wait_event_code==evMouse) MOUSE.get();
  123.         //return wait_event_code;
  124. }
  125.  
  126. inline fastcall dword CheckEvent()
  127. {
  128.         $mov eax,11
  129.         $int 0x40
  130. }
  131.  
  132. inline fastcall dword WaitEventTimeout(EBX)
  133. {
  134.         $mov eax,23
  135.         $int 0x40
  136. }
  137.  
  138. inline fastcall SetEventMask(EBX)
  139. {
  140.         $mov eax,40
  141.         $int 0x40
  142. }
  143.  
  144. inline fastcall ScancodesGeting(){
  145.         $mov eax,66
  146.         $mov ebx,1
  147.         $mov ecx,1 //сканкоды
  148.         $int 0x40
  149. }
  150.  
  151. inline fastcall GetStatusKey(){
  152.         $mov eax,66
  153.         $mov ebx,3
  154.         $int 0x40
  155. }
  156.  
  157. inline fastcall word GetKey()  //+Gluk fix
  158. {
  159.                 $push edx
  160. GETKEY:
  161.                 $mov  eax,2
  162.                 $int  0x40
  163.                 $cmp eax,1
  164.                 $jne GETKEYI
  165.                 $mov ah,dh
  166.                 $jmp GETKEYII //jz?
  167. GETKEYI:
  168.                 $mov dh,ah
  169.                 $jmp GETKEY
  170. GETKEYII:
  171.                 $pop edx
  172.                 $shr eax,8
  173. }
  174.  
  175. inline fastcall int GetFullKey()
  176. {
  177.         $mov  eax,2
  178.         $int  0x40
  179. }
  180.  
  181.  
  182. inline fastcall pause(EBX)
  183. {
  184.         $mov eax, 5
  185.         $int 0x40
  186. }
  187.  
  188. inline fastcall word GetButtonID()
  189. {
  190.         $mov eax,17
  191.         $int  0x40
  192.         $shr eax,8
  193. }
  194.  
  195. inline fastcall dword GetFreeRAM()
  196. {
  197.         $mov eax, 18
  198.         $mov ebx, 16
  199.         $int 0x40
  200.         //return eax = ЁрчьхЁ ётюсюфэющ ярь Єш т ъшыюсрщЄрї
  201. }
  202.  
  203. inline void draw_line(dword x1,y1,x2,y2,color)
  204. {
  205.         x2--;y2--;y1--;
  206.         $mov EAX,38
  207.         EBX = x1<<16;
  208.         EBX |= x2;
  209.         ECX = y1<<16;
  210.         ECX |= y2;
  211.         $mov EDX,color
  212.         $int 0x40
  213. }
  214.  
  215. inline fastcall dword LoadDriver(ECX) //ECX - шь  фЁрщтхЁр
  216. {
  217.         $mov eax, 68
  218.         $mov ebx, 16
  219.         $int 0x40
  220.         //return 0 - эхєфрўр, шэрўх eax = ї¤эфы фЁрщтхЁр
  221. }
  222.  
  223. inline fastcall dword RuleDriver(ECX) //єърчрЄхы№ эр єяЁрты ■∙є■ ёЄЁєъЄєЁє
  224. {
  225.         $mov eax, 68
  226.         $mov ebx, 17
  227.         $int 0x40
  228.         //return eax = юяЁхфхы хЄё  фЁрщтхЁюь
  229. }
  230.  
  231. struct proc_info
  232. {
  233.         #define SelfInfo -1
  234.         dword   use_cpu;
  235.         word    pos_in_stack,num_slot,rezerv1;
  236.         unsigned char name[11];
  237.         char    rezerv2;
  238.         dword   adress,use_memory,ID,left,top,width,height;
  239.         word    status_slot,rezerv3;
  240.         dword   work_left,work_top,work_width,work_height;
  241.         char    status_window;
  242.         dword   cwidth,cheight;
  243.         byte    reserved[1024-71-8];
  244. };
  245.  
  246. inline fastcall void GetProcessInfo(EBX, ECX)
  247. {
  248.         $mov eax,9;
  249.         $int  0x40
  250.         DSDWORD[EBX+71] = DSDWORD[EBX+42] - 9; //set cwidth
  251.         DSDWORD[EBX+75] = DSDWORD[EBX+46] - GetSkinHeight() - 4; //set cheight
  252. }
  253.  
  254. inline fastcall int GetPointOwner( EBX, ECX) //ebx=m.x, ecx=m.y
  255. {
  256.         $mov eax,34
  257.         $int 0x40
  258. }
  259.  
  260. inline fastcall int GetProcessSlot( ECX)
  261. {
  262.         EAX = 18;
  263.         EBX = 21;
  264.         $int 0x40
  265. }
  266.  
  267. inline fastcall int GetActiveProcess()
  268. {
  269.         EAX = 18;
  270.         EBX = 7;
  271.         $int 0x40
  272. }
  273.  
  274. :int CheckActiveProcess(int Form_ID)
  275. {
  276.         int id9=GetProcessSlot(Form_ID);
  277.         if (id9==GetActiveProcess()) return 1;
  278.         return 0;
  279. }
  280.  
  281. inline fastcall void ActivateWindow( ECX)
  282. {
  283.         EAX = 18;
  284.         EBX = 3;
  285.         $int 0x40
  286. }
  287.  
  288. inline fastcall int MinimizeWindow()
  289. {
  290.         EAX = 18;
  291.         EBX = 10;
  292.         $int 0x40
  293. }
  294.  
  295. inline fastcall int CreateThread(ECX,EDX)
  296. {
  297.         $mov eax,51
  298.         $mov ebx,1
  299.         $int 0x40
  300. }
  301.  
  302. inline fastcall void SwitchToAnotherThread()
  303. {
  304.         $mov eax,68
  305.         $mov ebx,1
  306.         $int 0x40
  307. }
  308.  
  309. inline fastcall int SendWindowMessage( ECX, EDX)
  310. {
  311.         $mov eax, 72
  312.         $mov ebx, 1
  313.         $int 0x40
  314. }
  315.  
  316. inline fastcall int KillProcess( ECX)
  317. {
  318.         $mov eax,18;
  319.         $mov ebx,18;
  320.         $int 0x40
  321. }
  322.  
  323. #define TURN_OFF 2
  324. #define REBOOT 3
  325. #define KERNEL 4
  326. inline fastcall int ExitSystem( ECX)
  327. {
  328.         $mov eax, 18
  329.         $mov ebx, 9
  330.         $int 0x40
  331. }
  332.  
  333. inline fastcall ExitProcess()
  334. {
  335.         $mov eax,-1;
  336.         $int 0x40
  337. }
  338.  
  339. //------------------------------------------------------------------------------
  340.  
  341. //eax =  ч√ъ ёшёЄхь√ (1=eng, 2=fi, 3=ger, 4=rus)
  342. inline fastcall int GetSystemLanguage()
  343. {
  344.         EAX = 26;
  345.         EBX = 5;
  346.         $int 0x40
  347. }
  348.  
  349. inline fastcall GetSkinHeight()
  350. {
  351.         $push ebx
  352.         $mov  eax,48
  353.         $mov  ebx,4
  354.         $int 0x40
  355.         $pop  ebx
  356. }
  357.  
  358. inline fastcall void SetSystemSkin( ECX)
  359. {
  360.         EAX = 48;
  361.         EBX = 8;
  362.         $int 0x40
  363. }
  364.  
  365. inline fastcall int GetScreenWidth()
  366. {
  367.         $mov eax, 14
  368.         $int 0x40
  369.         $shr eax, 16
  370. }
  371.  
  372. inline fastcall int GetScreenHeight()
  373. {
  374.         $mov eax, 14
  375.         $int 0x40
  376.         $and eax,0x0000FFFF
  377. }
  378.  
  379. inline fastcall int GetClientTop()
  380. {
  381.         $mov eax, 48
  382.         $mov ebx, 5
  383.         $int 0x40
  384.     $mov eax, ebx
  385.     $shr eax, 16
  386. }
  387.  
  388. inline fastcall int GetClientHeight()
  389. {
  390.         $mov eax, 48
  391.         $mov ebx, 5
  392.         $int 0x40
  393.     $mov eax, ebx
  394. }
  395.  
  396.  
  397. inline fastcall dword LoadLibrary( ECX)
  398. {
  399.         $mov eax, 68
  400.         $mov ebx, 19
  401.         $int  0x40
  402. }
  403.  
  404. inline fastcall int TestBit( EAX, CL)
  405. {
  406.         $shr eax,cl
  407.         $and eax,1
  408. }
  409.  
  410. inline fastcall int PlaySpeaker( ESI)
  411. {
  412.         $mov eax, 55
  413.         $mov ebx, 55
  414.         $int 0x40
  415. }
  416.  
  417. inline fastcall void debugln( EDX)
  418. {
  419.         $push eax
  420.         $push ebx
  421.         $push ecx
  422.         $mov eax, 63
  423.         $mov ebx, 1
  424. NEXT_CHAR:
  425.         $mov ecx, DSDWORD[edx]
  426.         $or      cl, cl
  427.         $jz  DONE
  428.         $int 0x40
  429.         $inc edx
  430.         $jmp NEXT_CHAR
  431. DONE:
  432.         $mov cl, 13
  433.         $int 0x40
  434.         $mov cl, 10
  435.         $int 0x40
  436.         $pop ecx
  437.         $pop ebx
  438.         $pop eax
  439. }
  440.  
  441. inline fastcall void debug( EDX)
  442. {
  443.         $push eax
  444.         $push ebx
  445.         $push ecx
  446.         $mov eax, 63
  447.         $mov ebx, 1
  448. NEXT_CHAR:
  449.         $mov ecx, DSDWORD[edx]
  450.         $or      cl, cl
  451.         $jz  DONE
  452.         $int 0x40
  453.         $inc edx
  454.         $jmp NEXT_CHAR
  455. DONE:
  456.         $pop ecx
  457.         $pop ebx
  458.         $pop eax
  459. }
  460.  
  461.  
  462. inline fastcall void debugch( ECX)
  463. {
  464.         $push eax
  465.         $push ebx
  466.         $mov eax,63
  467.         $mov ebx,1
  468.         $int 0x40
  469.         $pop ebx
  470.         $pop eax
  471. }
  472. //------------------------------------------------------------------------------
  473.  
  474. void DefineAndDrawWindow(dword x, y, size_w, size_h, byte WindowType,dword WindowAreaColor, EDI, ESI)
  475. {
  476.         EAX = 12;              // function 12:tell os about windowdraw
  477.         EBX = 1;
  478.         $int 0x40
  479.        
  480.         $xor EAX,EAX
  481.         EBX = x << 16 + size_w;
  482.         ECX = y << 16 + size_h;
  483.  
  484.         EDX = WindowType << 24 | WindowAreaColor;
  485.         $int 0x40
  486.  
  487.         EAX = 12;              // function 12:tell os about windowdraw
  488.         EBX = 2;
  489.         $int 0x40
  490. }
  491.  
  492. inline fastcall MoveSize( EBX,ECX,EDX,ESI)
  493. {
  494.         $mov eax, 67
  495.         $int 0x40
  496. }
  497.  
  498. inline fastcall void DrawTitle( ECX)
  499. {
  500.         EAX = 71;
  501.         EBX = 1;
  502.         $int 0x40;
  503. }
  504.  
  505. void WriteTextB(dword x,y,byte fontType, dword color, EDX)
  506. {
  507.         EAX = 4;
  508.         EBX = x<<16+y;
  509.         ECX = fontType<<24+color;
  510.         ESI = 0;
  511.         $int 0x40;
  512.         $add ebx, 1<<16
  513.         $int 0x40
  514. }
  515.  
  516. void WriteText(dword x,y,byte fontType, dword color, EDX)
  517. {
  518.         EAX = 4;
  519.         EBX = x<<16+y;
  520.         ECX = fontType<<24+color;
  521.         $int 0x40;
  522. }
  523.  
  524. dword WriteBufText(dword x,y,byte fontType, dword color, EDX, EDI)
  525. {
  526.         EAX = 4;
  527.         EBX = x<<16+y;
  528.         ECX = fontType<<24+color;
  529.         $int 0x40;
  530. }
  531.  
  532. void WriteNumber(dword x,y,byte fontType, dword color, count, ECX)
  533. {
  534.         EAX = 47;
  535.         EBX = count<<16;
  536.         EDX = x<<16+y;
  537.         ESI = fontType<<24+color;
  538.         $int 0x40;
  539. }
  540.  
  541. void CopyScreen(dword EBX, x, y, w, h)
  542. {
  543.   EAX = 36;
  544.   ECX = w << 16 + h;
  545.   EDX = x << 16 + y;
  546.   $int  0x40;
  547. }
  548.  
  549. :dword GetPixelColor(dword x, x_size, y)
  550. {
  551.         $mov eax, 35
  552.         EBX= y*x_size+x;
  553.         $int 0x40
  554. }
  555.  
  556.  
  557. void _PutImage(dword x,y, w,h, EBX)
  558. {
  559.         EAX = 7;
  560.         ECX = w<<16+h;
  561.         EDX = x<<16+y;
  562.         $int 0x40
  563. }
  564.  
  565. void PutPaletteImage(dword EBX,w,h,x,y,ESI,EDI)
  566. {
  567.         EAX = 65;
  568.         ECX = w<<16+h;
  569.         EDX = x<<16+y;
  570.         EBP = 0;
  571.         $int 0x40
  572. }
  573.  
  574. inline fastcall void PutPixel( EBX,ECX,EDX)
  575. {
  576.   EAX=1;
  577.   $int 0x40
  578. }
  579.  
  580. void DrawBar(dword x,y,w,h,EDX)
  581. {
  582.         if (h<=0) || (h>60000) || (w<=0) || (w>60000) return; //bad boy :)
  583.         EAX = 13;
  584.         EBX = x<<16+w;
  585.         ECX = y<<16+h;
  586.         $int 0x40
  587. }
  588.  
  589. void DefineButton(dword x,y,w,h,EDX,ESI)
  590. {
  591.         EAX = 8;
  592.         $push edx
  593.         EDX += BT_DEL;
  594.         $int 0x40;
  595.         $pop edx
  596.         EBX = x<<16+w;
  597.         ECX = y<<16+h;
  598.         $int 0x40
  599. }
  600.  
  601. inline RefreshWindow(dword ID_REFRESH,ID_ACTIVE)
  602. {
  603.         EAX = 18;
  604.         EBX = 22;
  605.         ECX = 3;
  606.         EDX = ID_REFRESH;
  607.         $int 0x40
  608.         EAX = 18;
  609.         EBX = 3;
  610.         EDX = ID_ACTIVE;
  611.         $int 0x40
  612. }
  613.  
  614. inline getIPC(ECX,EDX)
  615. {
  616.         $mov EAX,60
  617.         $mov EBX,2
  618.         $int 0x40
  619. }
  620.  
  621. inline sendIPC(ECX,EDX,ESI)
  622. {
  623.         $mov EAX,60
  624.         $mov EBX,1
  625.         $int 0x40
  626. }
  627.  
  628. void UnsafeDefineButton(dword x,y,w,h,EDX,ESI)
  629. {
  630.         EAX = 8;
  631.         EBX = x<<16+w;
  632.         ECX = y<<16+h;
  633.         $int 0x40
  634. }
  635.  
  636. inline fastcall void DeleteButton( EDX)
  637. {
  638.         EAX = 8;
  639.         EDX += BT_DEL;
  640.         $int 0x40
  641. }
  642.  
  643. inline fastcall dword GetStartTime()
  644. {
  645.         $mov eax,26
  646.         $mov ebx,9
  647.         $int 0x40
  648. }
  649.  
  650. :dword X_EventRedrawWindow,Y_EventRedrawWindow;
  651. :void _EventRedrawWindow()
  652. {
  653.         loop()switch(WaitEvent())
  654.         {
  655.                 case evReDraw:
  656.                         DefineAndDrawWindow(X_EventRedrawWindow,Y_EventRedrawWindow,100,1,1,0x34,0xFFFFFF,"");
  657.                         pause(10);
  658.                         ExitProcess();
  659.                         break;
  660.         }
  661. }
  662. :void EventRedrawWindow(dword x,y)
  663. {
  664.         dword mem = malloc(4096);
  665.         X_EventRedrawWindow = x;
  666.         Y_EventRedrawWindow = y;
  667.         CreateThread(#_EventRedrawWindow,mem+4092);
  668. }
  669.  
  670. :dword ALERT_TEXT;
  671. :void dialog_alert()
  672. {
  673.         byte id;
  674.         loop()switch(WaitEvent())
  675.         {
  676.                 case evReDraw:
  677.                         DefineAndDrawWindow(215,100,250,200,0x34,0xFFFFFF,"Alert");
  678.                         WriteTextB(5,5,0x90,0x0,ALERT_TEXT);
  679.                 break;
  680.                 case evKey:
  681.                 case evButton:
  682.                         id=GetButtonID();
  683.                         if (id==1) ExitProcess();
  684.                 break;
  685.         }
  686. }
  687. :dword alert(dword text)
  688. {
  689.         dword mem = malloc(4096);
  690.         ALERT_TEXT = text;
  691.         CreateThread(#dialog_alert,mem+4092);
  692.         return mem;
  693. }
  694.  
  695. :struct _screen
  696. {
  697.         dword width,height;
  698. } screen;
  699.  
  700. :struct _skin
  701. {
  702.         dword width,height;
  703. } SKIN;
  704.  
  705. :void DrawDate(dword x, y, color, in_date)
  706. {
  707.         //char text[15];
  708.         EDI = in_date;
  709.         EAX = 47;
  710.         EBX = 2<<16;
  711.         EDX = x<<16+y;
  712.         ESI = 0x80<<24+color;
  713.         ECX = EDI.date.day;
  714.         $int 0x40;
  715.         EDX += 18<<16;
  716.         ECX = EDI.date.month;
  717.         $int 0x40;
  718.         EDX += 18<<16;
  719.         EBX = 4<<16;
  720.         ECX = EDI.date.year;
  721.         $int 0x40;
  722.         PutPixel(x+14,y+6,color);
  723.         PutPixel(x+32,y+6,color);
  724.         //sprintf(#text,"%d",EDI.date.year);
  725.         //WriteText(x, y, 0x80, 0x000000, #text);
  726. }
  727.  
  728. :void __path_name__(dword BUF,PATH)
  729. {
  730.         dword beg = PATH;
  731.         dword pos = PATH;
  732.         dword sav = PATH;
  733.         dword i;
  734.         while(DSBYTE[pos])
  735.         {
  736.                 if(DSBYTE[pos]=='/')sav = pos;
  737.                 pos++;
  738.         }
  739.         i = sav-beg;
  740.         while(i)
  741.         {
  742.                 DSBYTE[BUF] = DSBYTE[beg];
  743.                 beg++;
  744.                 BUF++;
  745.                 i--;
  746.         }
  747.         /*while(DSBYTE[beg])
  748.         {
  749.                 DSBYTE[BUF1] = DSBYTE[beg];
  750.                 beg++;
  751.                 BUF1++;
  752.         }*/
  753.         //DSBYTE[BUF1] = 0;
  754.         DSBYTE[BUF] = 0;
  755. }
  756. char __BUF_DIR__[4096];
  757. :struct SELF
  758. {
  759.         dword dir;
  760.         dword file;
  761.         dword path;
  762. } self;
  763.  
  764. dword __generator;  // random number generator - фы  ухэхЁрЎшш ёыєўрщэ√ї ўшёхы
  765.  
  766. :dword program_path_length;
  767.  
  768. //The initialization of the initial data before running
  769. void ______INIT______()
  770. {
  771.         self.dir = #__BUF_DIR__;
  772.         self.file = 0;
  773.         self.path = I_Path;
  774.         __path_name__(#__BUF_DIR__,I_Path);
  775.        
  776.         SKIN.height   = GetSkinHeight();
  777.         screen.width  = GetScreenWidth();
  778.         screen.height = GetScreenHeight();
  779.        
  780.         //program_path_length = strlen(I_Path);
  781.         MOUSE_TIME = 50; //Default 500 ms.
  782.         __generator = GetStartTime();
  783.        
  784.         $push    ebx
  785.         $mov     eax, 68
  786.         $mov     ebx, 11
  787.         $int     0x40
  788.        
  789.         $pop     ebx
  790.  
  791.         main();
  792. }
  793. ______STOP______:
  794. #endif