Twili

load_symbols.c

Nov 24th, 2020
1,140
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #define sign(imm)    (unsigned short)(imm&0x8000)
  2. #define op(inst)     (unsigned char)(inst>>26)
  3. #define target(inst) (unsigned int)((inst&0x03ffffff)<<2)
  4. #define imm(inst)    (unsigned int)(inst&0xffff)
  5. #define funct(inst)  (unsigned char)(inst&0x3f)
  6. #define rs(inst)     (unsigned char)((inst&0x03e00000)>>21)
  7. #define rt(inst)     (unsigned char)((inst&0x001f0000)>>16)
  8. #define rd(inst)     (unsigned char)((inst&0xf800)>>11)
  9. #define sa(inst)     (unsigned char)((inst&0x07c0)>>6)
  10.  
  11. #define CART 0
  12. #include <stdio.h>
  13. #define DISK 1
  14. unsigned int addiu_jump[2]={4};
  15. int ovl_b=4,ovl_e=8,regs;
  16. char mapped=0;
  17. unsigned int extend(unsigned short imm);
  18. unsigned int extend(unsigned short imm)
  19. {
  20.      unsigned int extended;
  21.      if(sign(imm)==0x8000)
  22.      {
  23.           extended=0xffff0000|imm;
  24.      }
  25.      else
  26.      {
  27.           extended=imm;
  28.      }
  29.      return extended;
  30. }
  31.  
  32. unsigned int read32(unsigned char *RAM, int ptr);
  33. unsigned int read32(unsigned char *RAM, int ptr)
  34. {
  35.     return (unsigned int)((RAM[ptr]<<24)|(RAM[ptr+1]<<16)|(RAM[ptr+2]<<8)|RAM[ptr+3]);
  36. }
  37.  
  38. #define F3D_GBI     0
  39. #define F3DEX_GBI   1
  40. #define S2DEX_GBI   2
  41. #define F3DEX_GBI_2 3
  42.  
  43. void decompile_gfx(int map[8192], unsigned char gbi, int num_symb, int cmd_hi);
  44. void decompile_gfx(int map[8192], unsigned char gbi, int num_symb, int cmd_hi)
  45. {
  46.     int x;
  47.     char MV[4]={16, 16, 0, 0}, MW[4]={0, 0, 0, 16}, ucode=F3D_GBI;
  48.     for(x=0;x<num_symb;x+=1) //loop to detect which microcode the game uses
  49.     {
  50.         if(map[x]==0x0C){ucode=4;break;} //ZSort
  51.         if(map[x]==0xAF){ucode=F3DEX_GBI;break;}
  52.         if(map[x]==0xC1)
  53.         {
  54.             if(gbi==0x01){ucode=F3DEX_GBI;break;}
  55.             if(gbi>=0x02&&gbi<0x06){ucode=S2DEX_GBI;break;}
  56.             if(gbi==0x06){ucode=F3DEX_GBI;break;}
  57.             if(gbi==0xAF){ucode=F3DEX_GBI;break;}
  58.             if(gbi==0xB0){ucode=S2DEX_GBI;break;}
  59.             if(gbi==0xB1)
  60.             {
  61.                 if(cmd_hi>0x40){ucode=F3DEX_GBI;break;}
  62.                 if(cmd_hi<=0x40){ucode=S2DEX_GBI;break;}
  63.             }
  64.             if(gbi==0xB2){ucode=S2DEX_GBI;break;}
  65.             if(gbi>=0xB5&&gbi<0xC1){ucode=F3DEX_GBI;break;}
  66.             if(gbi>=0xC1){ucode=S2DEX_GBI;break;}
  67.         }
  68.         if(map[x]==0xE3){ucode=F3DEX_GBI_2;break;}
  69.     }
  70.     switch(gbi) //first try the hardwired commands
  71.     {
  72.         case 0xE4:
  73.             printf("gSPTextureRectangle");
  74.             break;
  75.         case 0xE5:
  76.             printf("gSPTextureRectangleFlip");
  77.             break;
  78.         case 0xE6:
  79.             printf("gDPLoadSync");
  80.             break;
  81.         case 0xE7:
  82.             printf("gDPPipeSync");
  83.             break;
  84.         case 0xE8:
  85.             printf("gDPTileSync");
  86.             break;
  87.         case 0xE9:
  88.             printf("gDPFullSync");
  89.             break;
  90.         case 0xEA:
  91.             printf("gDPSetKeyGB");
  92.             break;
  93.         case 0xEB:
  94.             printf("gDPSetKeyR");
  95.             break;
  96.         case 0xEC:
  97.             printf("gDPSetConvert");
  98.             break;
  99.         case 0xED:
  100.             printf("gDPSetScissor");
  101.             break;
  102.         case 0xEE:
  103.             printf("gDPSetPrimDepth");
  104.             break;
  105.         case 0xEF:
  106.             printf("gDPSetOtherMode");
  107.             break;
  108.         case 0xF0:
  109.             printf("gDPLoadTLUT");
  110.             break;
  111.         case 0xF2:
  112.             printf("gDPSetTileSize");
  113.             break;
  114.         case 0xF3:
  115.             printf("gDPLoadBlock");
  116.             break;
  117.         case 0xF4:
  118.             printf("gDPLoadTile");
  119.             break;
  120.         case 0xF5:
  121.             printf("gDPSetTile");
  122.             break;
  123.         case 0xF6:
  124.             printf("gDPFillRectangle");
  125.             break;
  126.         case 0xF7:
  127.             printf("gDPSetFillColor");
  128.             break;
  129.         case 0xF8:
  130.             printf("gDPSetFogColor");
  131.             break;
  132.         case 0xF9:
  133.             printf("gDPSetBlendColor");
  134.             break;
  135.         case 0xFA:
  136.             printf("gDPSetPrimColor");
  137.             break;
  138.         case 0xFB:
  139.             printf("gDPSetEnvColor");
  140.             break;
  141.         case 0xFC:
  142.             printf("gDPSetCombine");
  143.             break;
  144.         case 0xFD:
  145.             printf("gDPSetTextureImage");
  146.             break;
  147.         case 0xFE:
  148.             printf("gDPSetDepthImage");
  149.             break;
  150.         case 0xFF:
  151.             printf("gDPSetColorImage");
  152.             break;
  153.     }
  154.     if(ucode==F3D_GBI||ucode==F3DEX_GBI)
  155.     {
  156.         if(gbi==0x01){printf("gSPMatrix");return;}
  157.         if(gbi==0x03){goto MOVEMEM;}
  158.         if(gbi==0x04){printf("gSPVertex");return;}
  159.         if(gbi==0x06)
  160.         {
  161.             switch(cmd_hi>>16&0xff)
  162.             {
  163.                 case 0:
  164.                     printf("gSPDisplayList");
  165.                     break;
  166.                 case 1:
  167.                     printf("gSPBranchList");
  168.                     break;
  169.             }
  170.             return;
  171.         }
  172.         if(gbi==0xAF){printf("gSPLoadUcodeEx");return;}
  173.         if(gbi==0xB0){printf("gSPBranchLessZ");return;}
  174.         if(gbi==0xB1){printf("gSP2Triangles");return;}
  175.         if(gbi==0xB2){printf("gSPModifyVertex");return;}
  176.         if(gbi==0xB5){printf("gSP1Quadrangle");return;}
  177.         if(gbi==0xB6){printf("gSPClearGeometryMode");return;}
  178.         if(gbi==0xB7){printf("gSPSetGeometryMode");return;}
  179.         if(gbi==0xB8){printf("gSPEndDisplayList");return;}
  180.         if(gbi==0xB9)
  181.         {
  182.             x=cmd_hi>>8;
  183.             goto SETOTHERMODE_L;
  184.         }
  185.         if(gbi==0xBA)
  186.         {
  187.             x=cmd_hi>>8;
  188.             goto SETOTHERMODE_H;
  189.         }
  190.         if(gbi==0xBB){printf("gSPTexture");return;}
  191.         if(gbi==0xBC){goto MOVEWORD;}
  192.         if(gbi==0xBD){printf("gSPPopMatrix");return;}
  193.         if(gbi==0xBE){printf("gSPCullDisplayList");return;}
  194.         if(gbi==0xBF){printf("gSP1Triangle");return;}
  195.     }
  196.     else if(ucode==S2DEX_GBI)
  197.     {
  198.         if(gbi==0x01){printf("gSPBgRect1Cyc");}
  199.         if(gbi==0x02){printf("gSPBgRectCopy");}
  200.         if(gbi==0x03){printf("gSPObjRectangle");}
  201.         if(gbi==0x04){printf("gSPObjSprite");}
  202.         if(gbi==0x05)
  203.         {
  204.             switch(cmd_hi&0xffff)
  205.             {
  206.                 case 0:
  207.                     printf("gSPObjMatrix");
  208.                     break;
  209.                 case 2:
  210.                     printf("gSPObjSubMatrix");
  211.                     break;
  212.                 case 8:
  213.                     printf("gSPViewport");
  214.                     break;
  215.             }
  216.         }
  217.         if(gbi==0xB0)
  218.         {
  219.             switch(cmd_hi>>16&0xff)
  220.             {
  221.                 case 0:
  222.                     printf("gSPDisplayList");
  223.                     break;
  224.                 case 1:
  225.                     printf("gSPBranchList");
  226.                     break;
  227.             }
  228.         }
  229.         if(gbi==0xB1){printf("gSPObjRenderMode");}
  230.         if(gbi==0xB2){printf("gSPObjRectangleR");}
  231.         if(gbi==0xC1){printf("gSPObjLoadTxtr");}
  232.         if(gbi==0xC2){printf("gSPObjLoadTxSprite");}
  233.         if(gbi==0xC3){printf("gSPObjLoadTxRect");}
  234.         if(gbi==0xC4){printf("gSPObjLoadTxRectR");}
  235.         return;
  236.     }
  237.     else if(ucode==F3DEX_GBI_2)
  238.     {
  239.         if(gbi==0x01){printf("gSPVertex");return;}
  240.         if(gbi==0x02){printf("gSPModifyVertex");return;}
  241.         if(gbi==0x03){printf("gSPCullDisplayList");return;}
  242.         if(gbi==0x04){printf("gSPBranchLessZ");return;}
  243.         if(gbi==0x05){printf("gSP1Triangle");return;}
  244.         if(gbi==0x06){printf("gSP2Triangles");return;}
  245.         if(gbi==0x07){printf("gSP1Quadrangle");return;}
  246.         if(gbi==0xD7){printf("gSPTexture");return;}
  247.         if(gbi==0xD8){printf("gSPPopMatrix");return;}
  248.         if(gbi==0xD9){printf("gSPGeometryMode");return;}
  249.         if(gbi==0xDA){printf("gSPMatrix");return;}
  250.         if(gbi==0xDB){goto MOVEWORD;}
  251.         if(gbi==0xDC){goto MOVEMEM;}
  252.         if(gbi==0xDD){printf("gSPLoadUcodeEx");return;}
  253.         if(gbi==0xDE)
  254.         {
  255.             switch(cmd_hi>>16&0xff)
  256.             {
  257.                 case 0:
  258.                     printf("gSPDisplayList");
  259.                     break;
  260.                 case 1:
  261.                     printf("gSPBranchList");
  262.                     break;
  263.             }
  264.             return;
  265.         }
  266.         if(gbi==0xDF){printf("gSPEndDisplayList");return;}
  267.         if(gbi==0xE2)
  268.         {
  269.             x=32-(cmd_hi>>8);
  270.             cmd_hi&=0xFF;
  271.             x-=cmd_hi+1;
  272.             goto SETOTHERMODE_L;
  273.         }
  274.         if(gbi==0xE3)
  275.         {
  276.             x=32-(cmd_hi>>8);
  277.             cmd_hi&=0xFF;
  278.             x-=cmd_hi+1;
  279.             goto SETOTHERMODE_H;
  280.         }
  281.     }
  282.     else
  283.     {
  284.         if(gbi==0x04)
  285.         {
  286.             switch(cmd_hi&0xfff)
  287.             {
  288.                 case 0:
  289.                     printf("gSPZViewPort");
  290.                     break;
  291.                 case 0x830:
  292.                 case 0x870:
  293.                 case 0x8b0:
  294.                     if((cmd_hi>>23)&1==0)
  295.                     {
  296.                         printf("gSPZSetMtx");
  297.                     }
  298.                     else
  299.                     {
  300.                         printf("gSPZGetMtx");
  301.                     }
  302.                     break;
  303.                 default:
  304.                     printf("Unknown Move");
  305.                     break;
  306.             }
  307.         }
  308.         if(gbi==0x08){printf("gSPZMtxTrnsp3x3");}
  309.         if(gbi==0x0A){printf("gSPZMtxCat");}
  310.         if(gbi==0x0C){printf("gSPZMultMPMtx");}
  311.         if(gbi==0x0E){printf("gSPZRdpCmd");}
  312.         if(gbi==0x10){printf("gSPZSendMessage");}
  313.         if(gbi==0x12){printf("gSPZWaitSignal");}
  314.         if(gbi==0x14)
  315.         {
  316.             if((cmd_hi>>12)&0xfff>0)
  317.             {
  318.                 printf("gSPZLightMaterial");
  319.             }
  320.             else
  321.             {
  322.                 printf("gSPZLight");
  323.             }
  324.         }
  325.         if(gbi==0xE2){printf("Other Mode (L)");}
  326.         if(gbi==0xE3){printf("Other Mode (H)");}
  327.         return;
  328.     }
  329.     MOVEMEM:
  330.     switch(cmd_hi>>MV[ucode]&0xff)
  331.     {
  332.         case 0x08:
  333.         case 0x80:
  334.             printf("gSPViewport");
  335.             break;
  336.         case 0x0A:
  337.         case 0x86:
  338.         case 0x88:
  339.         case 0x8A:
  340.         case 0x8C:
  341.         case 0x8E:
  342.         case 0x90:
  343.         case 0x92:
  344.         case 0x94:
  345.             printf("gSPLight");
  346.             break;
  347.         case 0x0E:
  348.         case 0x9E:
  349.             printf("gSPForceMatrix");
  350.             break;
  351.     }
  352.     return;
  353.     SETOTHERMODE_L:
  354.     switch(x)
  355.     {
  356.         case 0:
  357.             printf("gDPSetAlphaCompare");
  358.             break;
  359.         case 2:
  360.             printf("gDPSetDepthSource");
  361.             break;
  362.         case 3:
  363.             printf("gDPSetRenderMode");
  364.             break;
  365.     }
  366.     return;
  367.     SETOTHERMODE_H:
  368.     switch(x)
  369.     {
  370.         case 4:
  371.             printf("gDPSetAlphaDither");
  372.             break;
  373.         case 6:
  374.             printf("gDPSetColorDither");
  375.             break;
  376.         case 8:
  377.             printf("gDPSetCombineKey");
  378.             break;
  379.         case 9:
  380.             printf("gDPSetTextureConvert");
  381.             break;
  382.         case 12:
  383.             printf("gDPSetTextureFilter");
  384.             break;
  385.         case 14:
  386.             printf("gDPSetTextureLUT");
  387.             break;
  388.         case 16:
  389.             printf("gDPSetTextureLOD");
  390.             break;
  391.         case 17:
  392.             printf("gDPSetTextureDetail");
  393.             break;
  394.         case 19:
  395.             printf("gDPSetTexturePersp");
  396.             break;
  397.         case 20:
  398.             printf("gDPSetCycleType");
  399.             break;
  400.         case 23:
  401.             printf("gDPPipelineMode");
  402.             break;
  403.     }
  404.     return;
  405.     MOVEWORD:
  406.     switch(cmd_hi>>MW[ucode]&0xff)
  407.     {
  408.         case 0x0:
  409.             printf("gSPInsertMatrix");
  410.             break;
  411.         case 0x2:
  412.             printf("gSPNumLights");
  413.             break;
  414.         case 0x4:
  415.             printf("gSPClipRatio");
  416.             break;
  417.         case 0x6:
  418.             printf("gSPSegment");
  419.             break;
  420.         case 0x8:
  421.             printf("gSPFogFactor");
  422.             break;
  423.         case 0xA:
  424.             printf("gSPLightColor");
  425.             break;
  426.         case 0xC:
  427.             printf("gSPModifyVertex");
  428.             break;
  429.         case 0xE:
  430.             printf("gSPPerspNormalize");
  431.             break;
  432.     }
  433. }
  434.  
  435. void message_set(unsigned char *RAM, unsigned int id)
  436. {
  437.     int found=0;
  438.     int seek=0;
  439.     int temp=0;
  440.     if((read32(RAM,0x3C)>>24)!=0x5A){return;}
  441.     if(read32(RAM,0x3C)==0x5A535001)
  442.     {
  443.     while(found!=id)
  444.     {
  445.         found=(int)((RAM[0xC71000+seek]<<8)|RAM[0xC71001+seek]);
  446.         seek+=8;
  447.         if(seek==0x8F58){break;}
  448.     }
  449.     if(seek==0x8F58){return;}
  450.     found=read32(RAM,0xC70FFC+seek)&0xffffff;
  451.     found+=0xAB000B;
  452.     seek=1;
  453.     while(seek!=0xBF)
  454.     {
  455.         seek=RAM[found+temp];
  456.         switch(seek)
  457.         {
  458.             case 0:
  459.             case 1:
  460.             case 2:
  461.             case 3:
  462.             case 4:
  463.             case 5:
  464.             case 6:
  465.             case 7:
  466.             case 8:
  467.             case 0xB:
  468.             case 0xC:
  469.             case 0xD:
  470.             case 0x13:
  471.             case 0x15:
  472.             case 0x16:
  473.             case 0x17:
  474.             case 0x18:
  475.             case 0x19:
  476.             case 0x1A:
  477.             case 0xC2:
  478.             case 0xC3:
  479.             case 0xC4:
  480.             case 0xC8:
  481.             case 0xCC:
  482.             case 0xCD:
  483.             case 0xCE:
  484.             case 0xCF:
  485.             case 0xD0:
  486.             case 0xD1:
  487.             case 0xD2:
  488.             case 0xD4:
  489.             case 0xD5:
  490.             case 0xD7:
  491.             case 0xD8:
  492.             case 0xD9:
  493.             case 0xDA:
  494.             case 0xDB:
  495.             case 0xDC:
  496.             case 0xDD:
  497.             case 0xDE:
  498.             case 0xDF:
  499.             case 0xE0:
  500.             case 0xE1:
  501.             case 0xE2:
  502.             case 0xE3:
  503.             case 0xE4:
  504.             case 0xE5:
  505.             case 0xE6:
  506.             case 0xE7:
  507.             case 0xE8:
  508.             case 0xF6:
  509.             case 0xF9:
  510.             case 0xFA:
  511.             case 0xFB:
  512.             case 0xFC:
  513.                 temp+=1;
  514.                 break;
  515.             case 0x10:
  516.             case 0x12:
  517.                 temp+=1;
  518.                 printf("\n==\n");
  519.                 break;
  520.             case 0x11:
  521.                 temp+=1;
  522.                 printf("\n");
  523.                 break;
  524.             case 0x1B:
  525.             case 0x1C:
  526.             case 0x1D:
  527.             case 0x1F:
  528.                 temp+=3;
  529.                 break;
  530.             case 0x1E:
  531.                 temp+=3;
  532.                 break;
  533.             case 0xBF:
  534.                 temp+=1;
  535.                 printf("\n\n\n");
  536.                 break;
  537.             default:
  538.                 temp+=1;
  539.                 printf("%c",seek);
  540.                 break;
  541.         }
  542.     }
  543.     system("pause");
  544.     return;
  545.     }
  546.     while(found!=id)
  547.     {
  548.         found=(int)((RAM[0xBC24C0+seek]<<8)|RAM[0xBC24C1+seek]);
  549.         seek+=8;
  550.         if(seek==0x4210){break;}
  551.     }
  552.     if(seek==0x4210){return;}
  553.     found=read32(RAM,0xBC24BC+seek)&0xffffff;
  554.     found+=0x8C6000;
  555.     seek=1;
  556.     while(seek!=2)
  557.     {
  558.         seek=RAM[found+temp];
  559.         switch(seek)
  560.         {
  561.             case 3:
  562.             case 8:
  563.             case 9:
  564.             case 0xA:
  565.             case 0xB:
  566.             case 0xD:
  567.             case 0xF:
  568.             case 0x10:
  569.             case 0x11:
  570.             case 0x16:
  571.             case 0x17:
  572.             case 0x18:
  573.             case 0x19:
  574.             case 0x1A:
  575.             case 0x1B:
  576.             case 0x1C:
  577.             case 0x1D:
  578.             case 0x1F:
  579.                 temp+=1;
  580.                 break;
  581.             case 1:
  582.                 temp+=1;
  583.                 printf("\n");
  584.                 break;
  585.             case 2:
  586.                 temp+=1;
  587.                 printf("\n\n\n");
  588.                 break;
  589.             case 4:
  590.                 temp+=1;
  591.                 printf("\n==\n");
  592.                 break;
  593.             case 7:
  594.                 temp+=3;
  595.                 break;
  596.             case 0x12:
  597.                 temp+=3;
  598.                 break;
  599.             case 0x15:
  600.                 temp+=4;
  601.                 break;
  602.             case 5:
  603.             case 6:
  604.             case 0xC:
  605.             case 0xE:
  606.             case 0x13:
  607.             case 0x14:
  608.             case 0x1E:
  609.                 temp+=2;
  610.                 break;
  611.             default:
  612.                 temp+=1;
  613.                 printf("%c",seek);
  614.                 break;
  615.         }
  616.     }
  617.     system("pause");
  618. }
  619.  
  620. void map(unsigned char *RAM, unsigned char *REG, int add, int start, int offset)
  621. {
  622.     unsigned int CPU[32], inst, tgt;
  623.     int loop, newvar, newvar2;
  624.     int found=0, there;
  625.     CPU[0]=0;
  626.     newvar=offset-read32(RAM,offset-4);
  627.     int len=read32(RAM,newvar);
  628.     newvar2=len;
  629.     newvar2+=read32(RAM,newvar+4);
  630.     newvar2+=read32(RAM,newvar+8);
  631.     regs=start-add+newvar2;
  632.     for(loop=0;loop<len;loop+=4)
  633.     {
  634.         inst=read32(RAM,start+loop);
  635.         switch(op(inst))
  636.         {
  637.             case ADDIU:
  638.                 tgt=rt(inst);
  639.                 CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
  640.                 break;
  641.             case LUI:
  642.                 tgt=imm(inst);
  643.                 CPU[rt(inst)]=tgt<<16;
  644.                 break;
  645.             case SB:
  646.                 tgt=CPU[rs(inst)]+extend(imm(inst));
  647.                 if(rs(inst)==AT&&tgt>=(regs|0x80000000))
  648.                 {
  649.                     tgt&=0x1fffffff;
  650.                     tgt-=regs;
  651.                     REG[tgt]=CPU[rt(inst)];
  652.                 }
  653.                 break;
  654.             case SH:
  655.                 tgt=CPU[rs(inst)]+extend(imm(inst));
  656.                 if(rs(inst)==AT&&tgt>=(regs|0x80000000))
  657.                 {
  658.                     tgt&=0x1fffffff;
  659.                     tgt-=regs;
  660.                     REG[tgt]=CPU[rt(inst)]>>8;
  661.                     REG[tgt+1]=CPU[rt(inst)]&0xff;
  662.                 }
  663.                 break;
  664.             case SW:
  665.                 tgt=CPU[rs(inst)]+extend(imm(inst));
  666.                 if(rs(inst)==AT&&tgt>=(regs|0x80000000))
  667.                 {
  668.                     tgt&=0x1fffffff;
  669.                     tgt-=regs;
  670.                     REG[tgt]=CPU[rt(inst)]>>24;
  671.                     REG[tgt+1]=(CPU[rt(inst)]>>16)&0xff;
  672.                     REG[tgt+2]=(CPU[rt(inst)]>>8)&0xff;
  673.                     REG[tgt+3]=CPU[rt(inst)]&0xff;
  674.                 }
  675.                 break;
  676.         }
  677.     }
  678.     scan:
  679.     if(RAM[0x3C]==0x5A&&RAM[0x3D]==0x53)
  680.     {
  681.         if(found!=1)
  682.         {
  683.             found=0;
  684.             there=start+len;
  685.         }
  686.         while(RAM[there]!=0x80)
  687.         {
  688.             if(RAM[there]==0x0E)
  689.             {
  690.                 if(RAM[there+3]==0x0C&&RAM[there+5]==0)
  691.                 {
  692.                     found=there;
  693.                     break;
  694.                 }
  695.                 if(RAM[there+3]==0x2D&&RAM[there+4]==0)
  696.                 {
  697.                     found=there;
  698.                     break;
  699.                 }
  700.             }
  701.             there+=1;
  702.         }
  703.         if(found==0)
  704.         {
  705.             while(RAM[there]==0x80)
  706.             {
  707.                 there+=4;
  708.             }
  709.             found=1;
  710.             goto scan;
  711.            
  712.         }
  713.         if(found>1)
  714.         {
  715.             there=found;
  716.             while(RAM[there]!=0x80) //PROCESS THE SCRIPT
  717.             {
  718.                 switch(RAM[there])
  719.                 {
  720.                     case 0x0E:
  721.                     case 0x0F:
  722.                     case 0x2C:
  723.                         if((unsigned short)((RAM[there+1]<<8)|RAM[there+2])>0)
  724.                         {
  725.                             printf("================================\n0x%04x\n\n",(unsigned short)(RAM[there+1]<<8)|RAM[there+2]);
  726.                             message_set(RAM,(unsigned short)(RAM[there+1]<<8)|RAM[there+2]);
  727.                             printf("\n");
  728.                             there+=2;
  729.                         }
  730.                         break;
  731.                     case 0x2D:
  732.                         printf("\n\n");
  733.                         there+=2;
  734.                 }
  735.                 there+=1;
  736.             }
  737.         }
  738.     }
  739. }
  740.  
  741. int ovl_adapt(unsigned char *RAM, unsigned char *REG, int func, unsigned int magic)
  742. {
  743.     int loop, add;
  744.     add=0;
  745.     if(magic!=0x5A4C450F){goto ZS;}
  746.     for(loop=0;loop<0x1FC;loop+=1)
  747.     {
  748.         if(loop>=0x1D7)
  749.         {
  750.             RAM[0xB897D4+0x1C*loop]=0;
  751.             if(func>=read32(RAM,0xB897CC+0x1C*loop)&&func<read32(RAM,0xB897D0+0x1C*loop))
  752.             {
  753.                 add=read32(RAM,0xB897CC+0x1C*loop)-read32(RAM,0xB897D4+0x1C*loop);
  754.                 break;
  755.             }
  756.         }
  757.         else
  758.         {
  759.             RAM[0xB8D448+0x20*loop]=0;
  760.             RAM[0xB8D458+0x20*loop]=0;
  761.             if(func>=read32(RAM,0xB8D440+0x20*loop)&&func<read32(RAM,0xB8D444+0x20*loop))
  762.             {
  763.                 add=read32(RAM,0xB8D440+0x20*loop)-read32(RAM,0xB8D448+0x20*loop);
  764.                 break;
  765.             }
  766.         }
  767.     }
  768.     if(mapped==1)
  769.     {
  770.         if(func<ovl_b||func>=ovl_e)
  771.         {
  772.             for(magic=0;magic<0x40000;magic+=1)
  773.             {
  774.                 REG[magic]=0;
  775.             }
  776.             mapped=0;
  777.         }
  778.     }
  779.     if(mapped==0)
  780.     {
  781.         if(loop>=0x1D7)
  782.         {
  783.             ovl_b=read32(RAM,0xB897CC+0x1C*loop);
  784.             ovl_e=read32(RAM,0xB897D0+0x1C*loop);
  785.         }
  786.         else
  787.         {
  788.             if(loop<0x1FC)
  789.             {
  790.             ovl_b=read32(RAM,0xB8D440+0x20*loop);
  791.             ovl_e=read32(RAM,0xB8D444+0x20*loop);
  792.             }
  793.         }
  794.         if(loop<0x1FC)
  795.         {
  796.             map(RAM,REG,add,ovl_b,ovl_e);
  797.             mapped=1;
  798.         }
  799.     }
  800.     return add;
  801.     ZS:
  802.     for(loop=0;loop<0x2D9;loop+=1)
  803.     {
  804.         if(loop>=0x2B2)
  805.         {
  806.             RAM[0xDD03B0+0x1C*loop]=0;
  807.             if(func>=read32(RAM,0xDD03A8+0x1C*loop)&&func<read32(RAM,0xDD03AC+0x1C*loop))
  808.             {
  809.                 add=read32(RAM,0xDD03A8+0x1C*loop)-read32(RAM,0xDD03B0+0x1C*loop);
  810.                 break;
  811.             }
  812.         }
  813.         else
  814.         {
  815.             RAM[0xDD5A58+0x20*loop]=0;
  816.             RAM[0xDD5A68+0x20*loop]=0;
  817.             if(func>=read32(RAM,0xDD5A50+0x20*loop)&&func<read32(RAM,0xDD5A54+0x20*loop))
  818.             {
  819.                 add=read32(RAM,0xDD5A50+0x20*loop)-read32(RAM,0xDD5A58+0x20*loop);
  820.                 break;
  821.             }
  822.         }
  823.     }
  824.     if(mapped==1)
  825.     {
  826.         if(func<ovl_b||func>=ovl_e)
  827.         {
  828.             for(magic=0;magic<0x40000;magic+=1)
  829.             {
  830.                 REG[magic]=0;
  831.             }
  832.             mapped=0;
  833.         }
  834.     }
  835.     if(mapped==0)
  836.     {
  837.         if(loop>=0x2B2)
  838.         {
  839.             ovl_b=read32(RAM,0xDD03A8+0x1C*loop);
  840.             ovl_e=read32(RAM,0xDD03AC+0x1C*loop);
  841.         }
  842.         else
  843.         {
  844.             if(loop<0x2D9)
  845.             {
  846.             ovl_b=read32(RAM,0xDD5A50+0x20*loop);
  847.             ovl_e=read32(RAM,0xDD5A54+0x20*loop);
  848.             }
  849.         }
  850.         if(loop<0x2D9)
  851.         {
  852.             map(RAM,REG,add,ovl_b,ovl_e);
  853.             mapped=1;
  854.         }
  855.     }
  856.     return add;
  857. }
  858.  
  859. char pointers[1532][64]={0};
  860. unsigned short exit_list[31];
  861. int scene_start;
  862.  
  863. void exits(unsigned char *RAM, int start_offset, char mode, short x_doord, short y_doord, short z_doord)
  864. {
  865.     int exit_table, pointer;
  866.     int edge_where, poly_where, type_where, x;
  867.     short highest=0, poly_load, poly_type, x_coord, y_coord, z_coord;
  868.     int scene_depth=start_offset;
  869.     while(RAM[scene_depth]!=0x14)
  870.     {
  871.         if(RAM[scene_depth]==3)
  872.         {
  873.             pointer=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
  874.         }
  875.         if(RAM[scene_depth]==0x13)
  876.         {
  877.             exit_table=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
  878.         }
  879.         scene_depth+=8;
  880.     }
  881.     if(mode<2)
  882.     {
  883.     edge_where=scene_start+(read32(RAM,pointer+16)&0xffffff);
  884.     poly_load=(short)((RAM[pointer+20]<<8)|RAM[pointer+21]);
  885.     poly_where=scene_start+(read32(RAM,pointer+24)&0xffffff);
  886.     type_where=scene_start+(read32(RAM,pointer+28)&0xffffff);
  887.     if(mode==0)
  888.     {
  889.     for(x=0;x<31;x+=1){exit_list[x]=0xFFFF;}
  890.     for(x=0;x<(poly_load*16);x+=16)
  891.     {
  892.         poly_type=(short)((RAM[poly_where+x]<<8)|RAM[1+poly_where+x]);
  893.         scene_depth=RAM[2+type_where+poly_type*8]&0x1f;
  894.         if(scene_depth>highest)
  895.         {
  896.             highest=scene_depth;
  897.         }
  898.     }
  899.     for(x=0;x<(highest*2);x+=2)
  900.     {
  901.         exit_list[(x/2)]=(short)((RAM[exit_table+x]<<8)|RAM[1+exit_table+x]);
  902.     }
  903.     }
  904.     if(mode==1)
  905.     {
  906.     for(x=0;x<(poly_load*16);x+=16)
  907.     {
  908.         poly_type=(short)((RAM[poly_where+x]<<8)|RAM[1+poly_where+x]);
  909.         scene_depth=RAM[2+type_where+poly_type*8]&0x1f;
  910.         exit_table=(short)((RAM[2+poly_where+x]<<8)|RAM[3+poly_where+x]);
  911.         exit_table&=0x1fff;
  912.         x_coord=(short)((RAM[edge_where+exit_table*6]<<8)|RAM[1+edge_where+exit_table*6]);
  913.         y_coord=(short)((RAM[2+edge_where+exit_table*6]<<8)|RAM[3+edge_where+exit_table*6]);
  914.         z_coord=(short)((RAM[4+edge_where+exit_table*6]<<8)|RAM[5+edge_where+exit_table*6]);
  915.         if(y_coord>=y_doord&&y_coord<(y_doord+16))
  916.         {
  917.             if(z_coord>=(z_doord-32)&&z_coord<(z_doord+32))
  918.             {
  919.             if(scene_depth>0&&exit_list[scene_depth-1]<0xFFFF)
  920.             {
  921.                 if(read32(RAM,0x3C)==0x5A535001)
  922.                 {
  923.                 RAM[0xDECD3C+0xC*(exit_list[scene_depth-1]>>9)]=0;
  924.                 RAM[0xDECD40+0xC*(exit_list[scene_depth-1]>>9)]=0;
  925.                 exit_table=0xBDE540+read32(RAM,0xDECD3C+0xC*(exit_list[scene_depth-1]>>9));
  926.                 pointer=0xBDE540+read32(RAM,0xDECD40+0xC*(exit_list[scene_depth-1]>>9));
  927.                 RAM[exit_table]=0;
  928.                 edge_where=0xBDE540+read32(RAM,exit_table);
  929.                 exit_table=RAM[edge_where];
  930.                 if(exit_table>127)
  931.                 {
  932.                     exit_table=256-exit_table;
  933.                 }
  934.                 printf("->%02X ",exit_table);
  935.                 exit_table=1;
  936.                 edge_where=0;
  937.                 while(exit_table!=0)
  938.                 {
  939.                     exit_table=RAM[pointer+edge_where];
  940.                     edge_where+=1;
  941.                     printf("%c",exit_table);
  942.                 }
  943.                 printf("(%02X)",scene_depth-1);
  944.                 }
  945.                 else
  946.                 {
  947.                 pointer=RAM[0xB9F360+exit_list[scene_depth-1]*4];
  948.                 exit_table=read32(RAM,0xBA0BB0+pointer*0x14);
  949.                 for(x_coord=0;x_coord<1532;x_coord+=1)
  950.                 {
  951.                     if(read32(RAM,0x12F70+x_coord*16)==exit_table)
  952.                     {
  953.                         break;
  954.                     }
  955.                 }
  956.                 printf("->%02X %s (%02X)",pointer,pointers[x_coord],scene_depth-1);
  957.                 }
  958.                 exit_list[scene_depth-1]=0xFFFF;
  959.                 break;
  960.             }
  961.             }
  962.         }
  963.     }
  964.     }
  965.     }
  966.     if(mode==2)
  967.     {
  968.         for(x=0;x<31;x+=1)
  969.         {
  970.             if(exit_list[x]<0xFFFF)
  971.             {
  972.                 if(read32(RAM,0x3C)==0x5A535001)
  973.                 {
  974.                 RAM[0xDECD3C+0xC*(exit_list[x]>>9)]=0;
  975.                 RAM[0xDECD40+0xC*(exit_list[x]>>9)]=0;
  976.                 exit_table=0xBDE540+read32(RAM,0xDECD3C+0xC*(exit_list[x]>>9));
  977.                 pointer=0xBDE540+read32(RAM,0xDECD40+0xC*(exit_list[x]>>9));
  978.                 RAM[exit_table]=0;
  979.                 edge_where=0xBDE540+read32(RAM,exit_table);
  980.                 exit_table=RAM[edge_where];
  981.                 if(exit_table>127)
  982.                 {
  983.                     exit_table=256-exit_table;
  984.                 }
  985.                 printf("%02X ",exit_table);
  986.                 exit_table=1;
  987.                 edge_where=0;
  988.                 while(exit_table!=0)
  989.                 {
  990.                     exit_table=RAM[pointer+edge_where];
  991.                     edge_where+=1;
  992.                     printf("%c",exit_table);
  993.                 }
  994.                 printf("(%02X)\n",x);
  995.                 }
  996.                 else
  997.                 {
  998.                 pointer=RAM[0xB9F360+exit_list[x]*4];
  999.                 exit_table=read32(RAM,0xBA0BB0+pointer*0x14);
  1000.                 for(x_coord=0;x_coord<1532;x_coord+=1)
  1001.                 {
  1002.                     if(read32(RAM,0x12F70+x_coord*16)==exit_table)
  1003.                     {
  1004.                         break;
  1005.                     }
  1006.                 }
  1007.                 printf("%02X %s (%02X)\n",pointer,pointers[x_coord],x);
  1008.                 }
  1009.             }
  1010.         }
  1011.     }
  1012. }
  1013.  
  1014. void doors(unsigned char *RAM, int start_offset, int zenum_add[8192], char zenum_sym[8192][128])
  1015. {
  1016.     int scene_depth=start_offset;
  1017.     int offset, offset2, offset3, offset4, loop;
  1018.     unsigned short type;
  1019.     unsigned char doors;
  1020.     if(read32(RAM,0x3C)==0x5A535001)
  1021.     {
  1022.         goto MM;
  1023.     }
  1024.     while(RAM[scene_depth]!=0x14)
  1025.     {
  1026.         if(RAM[scene_depth]==0xE)
  1027.         {
  1028.             doors=RAM[scene_depth+1];
  1029.             offset=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
  1030.             for(offset2=offset;offset2<(offset+doors*0x10);offset2+=0x10)
  1031.             {
  1032.                 for(loop=0;loop<0x1AD;loop+=1)
  1033.                 {
  1034.                     if((unsigned short)((RAM[4+offset2]<<8)|RAM[5+offset2])==zenum_add[loop])
  1035.                     {
  1036.                         printf("%08X %s",offset2,zenum_sym[loop]);
  1037.                         exits(RAM,start_offset,1,(short)((RAM[6+offset2]<<8)|RAM[7+offset2]),(short)((RAM[8+offset2]<<8)|RAM[9+offset2]),(short)((RAM[10+offset2]<<8)|RAM[11+offset2]));
  1038.                         printf("\n");
  1039.                         switch(zenum_add[loop])
  1040.                         {
  1041.                             case 9:
  1042.                                 type=(unsigned short)(((RAM[14+offset2]&3)<<1)|(RAM[15+offset2]>>7));
  1043.                                 if(type>=4&&type<7)
  1044.                                 {
  1045.                                     message_set(RAM,0x200+(RAM[15+offset2]&0x3f));
  1046.                                 }
  1047.                         }
  1048.                         break;
  1049.                     }
  1050.                 }
  1051.             }
  1052.             break;
  1053.         }
  1054.         scene_depth+=8;
  1055.     }
  1056.     return;
  1057.     MM:
  1058.     while(RAM[scene_depth]!=0x14)
  1059.     {
  1060.         if(RAM[scene_depth]==0xE)
  1061.         {
  1062.             doors=RAM[scene_depth+1];
  1063.             offset=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
  1064.             for(offset2=offset;offset2<(offset+doors*0x10);offset2+=0x10)
  1065.             {
  1066.                 for(loop=0x1AD;loop<0x3EC;loop+=1)
  1067.                 {
  1068.                     if((unsigned short)((RAM[4+offset2]<<8)|RAM[5+offset2])==zenum_add[loop])
  1069.                     {
  1070.                         printf("%08X %s",offset2,zenum_sym[loop]);
  1071.                         exits(RAM,start_offset,1,(short)((RAM[6+offset2]<<8)|RAM[7+offset2]),(short)((RAM[8+offset2]<<8)|RAM[9+offset2]),(short)((RAM[10+offset2]<<8)|RAM[11+offset2]));
  1072.                         printf("\n");
  1073.                         switch(zenum_add[loop])
  1074.                         {
  1075.                             case 5:
  1076.                                 type=(unsigned short)(((RAM[14+offset2]&3)<<1)|(RAM[15+offset2]>>7));
  1077.                                 if(type==5)
  1078.                                 {
  1079.                                     offset3=0x612500+(read32(RAM,0xE8584C+(RAM[15+offset2]&0x7F)*4)&0xffffff);
  1080.                                     offset4=0x612500+(read32(RAM,0xE85850+(RAM[15+offset2]&0x7F)*4)&0xffffff);
  1081.                                     while(type!=9)
  1082.                                     {
  1083.                                         type=RAM[offset3];
  1084.                                         switch(type)
  1085.                                         {
  1086.                                             case 0xE:
  1087.                                             case 0xF:
  1088.                                             case 0x2C:
  1089.                                             case 0x2D:
  1090.                                                 offset3+=2;
  1091.                                         }
  1092.                                         offset3+=1;
  1093.                                         if((RAM[15+offset2]&0x7F)<0x1F&&offset3>=offset4){break;}
  1094.                                     }
  1095.                                     if(type==9){message_set(RAM,0x1800+RAM[offset3]);}
  1096.                                 }
  1097.                         }
  1098.                         break;
  1099.                     }
  1100.                 }
  1101.             }
  1102.             break;
  1103.         }
  1104.         scene_depth+=8;
  1105.     }
  1106. }
  1107.  
  1108. void scene(unsigned char *RAM, int func, int zenum_add[8192], char zenum_sym[8192][128])
  1109. {
  1110.     int setup[0x80]={0},offset2,offset3,object_list=0;
  1111.     unsigned char count=0, count2, object_count=0;
  1112.     int offset, loop, loop2, loop3;
  1113.     if(read32(RAM,0x3C)==0x5A535001)
  1114.     {
  1115.         offset=read32(RAM,0xDEB2B0+func*0x10);
  1116.     }
  1117.     else
  1118.     {
  1119.         offset=read32(RAM,0xBA0BB0+func*0x14);
  1120.         if(func>=0x6E){return;}
  1121.     }
  1122.     int scene_depth=offset;
  1123.     int start_offset2=offset;
  1124.     scene_start=offset;
  1125.     exits(RAM,start_offset2,0,0,0,0);
  1126.     while(RAM[scene_depth]!=4)
  1127.     {
  1128.         scene_depth+=8;
  1129.     }
  1130.     unsigned char rooms=RAM[scene_depth+1];
  1131.     offset+=read32(RAM,scene_depth+4)&0xffffff;
  1132.     pick:
  1133.     if(rooms>1)
  1134.     {
  1135.         printf("Pick a room (0 - %d)\n?",rooms-1);
  1136.         scanf("%d",&scene_depth);
  1137.         if(scene_depth>=rooms){goto pick;}
  1138.     }
  1139.     else
  1140.     {
  1141.         scene_depth=0;
  1142.     }
  1143.     offset=read32(RAM,(int)(offset+scene_depth*8));
  1144.     int start_offset=offset;
  1145.     rooms=0;
  1146.     scan_again:
  1147.     if(count>0)
  1148.     {
  1149.         count=0;
  1150.         loop=0;
  1151.         exits(RAM,start_offset2,0,0,0,0);
  1152.     }
  1153.     scene_depth=offset;
  1154.     while(RAM[scene_depth]!=0x14)
  1155.     {
  1156.         switch(RAM[scene_depth])
  1157.         {
  1158.             case 0x01:
  1159.                 count2=RAM[scene_depth+1];
  1160.                 offset3=read32(RAM,scene_depth+4)&0xffffff;
  1161.                 offset3+=start_offset;
  1162.                 break;
  1163.             case 0x0B:
  1164.                 object_count=RAM[scene_depth+1];
  1165.                 object_list=read32(RAM,scene_depth+4)&0xffffff;
  1166.                 object_list+=start_offset;
  1167.                 break;
  1168.             case 0x18:
  1169.                 offset2=0xC+(read32(RAM,scene_depth+4)&0xffffff);
  1170.                 if(RAM[0x3f]==1)
  1171.                 {
  1172.                     offset2=read32(RAM,scene_depth+4)&0xffffff;
  1173.                 }
  1174.                 offset2+=offset;
  1175.                 while(rooms<4)
  1176.                 {
  1177.                     rooms=RAM[offset2];
  1178.                     if(rooms!=3){break;}
  1179.                     setup[count]=(read32(RAM,offset2)&0xffffff)+offset;
  1180.                     count+=1;
  1181.                     offset2+=4;
  1182.                 }
  1183.                 break;
  1184.         }
  1185.         scene_depth+=8;
  1186.     }
  1187.     pick2:
  1188.     if(count>0)
  1189.     {
  1190.         printf("Use a setup? (0 - %d) (Enter %d to refuse!)\n",(count-1),count);
  1191.         scanf("%d",&scene_depth);
  1192.     }
  1193.     if(count>0&&scene_depth>=(count+1)){goto pick2;}
  1194.     if(count>0&&scene_depth<count)
  1195.     {
  1196.         offset=setup[scene_depth];
  1197.         loop=start_offset2;
  1198.         while(RAM[loop]!=0x14)
  1199.         {
  1200.             if(RAM[loop]==0x18)
  1201.             {
  1202.                 offset2=0xC+(read32(RAM,loop+4)&0xffffff)+scene_depth*4;
  1203.                 if(RAM[0x3f]==1)
  1204.                 {
  1205.                     offset2=(read32(RAM,loop+4)&0xffffff)+scene_depth*4;
  1206.                 }
  1207.                 offset2+=start_offset2;
  1208.                 start_offset2+=read32(RAM,offset2)&0xffffff;
  1209.                 break;
  1210.             }
  1211.             loop+=8;
  1212.         }
  1213.         goto scan_again;
  1214.     }
  1215.     printf("%08X (%08X)\n",start_offset2-scene_start,start_offset2);
  1216.     doors(RAM,start_offset2,zenum_add,zenum_sym);
  1217.     exits(RAM,start_offset2,2,0,0,0);
  1218.     if(read32(RAM,0x3C)==0x5A535001)
  1219.     {
  1220.         goto majora;
  1221.     }
  1222.     for(scene_depth=0;scene_depth<count2;scene_depth+=1)
  1223.     {
  1224.         for(offset=0;offset<0x1AD;offset+=1)
  1225.         {
  1226.             if((unsigned short)((RAM[offset3+scene_depth*16]<<8)|RAM[1+offset3+scene_depth*16])==zenum_add[offset])
  1227.             {
  1228.                 printf("%08X %s\n",(offset3+scene_depth*16),zenum_sym[offset]);
  1229.                 switch(zenum_add[offset])
  1230.                 {
  1231.                     case 0x39:
  1232.                         if(RAM[15+offset3+scene_depth*16]==9||RAM[15+offset3+scene_depth*16]==10)
  1233.                         {
  1234.                             message_set(RAM,0x300+RAM[14+offset3+scene_depth*16]);
  1235.                         }
  1236.                         break;
  1237.                     case 0x141:
  1238.                         message_set(RAM,0x300+RAM[15+offset3+scene_depth*16]);
  1239.                         break;
  1240.                     case 0x11B:
  1241.                         message_set(RAM,0x100+RAM[15+offset3+scene_depth*16]);
  1242.                         break;
  1243.                     case 0x185:
  1244.                         message_set(RAM,0x200+(unsigned char)((RAM[14+offset3+scene_depth*16]<<2)|(RAM[15+offset3+scene_depth*16]>>6)));
  1245.                         break;
  1246.                     case 0x1B9:
  1247.                         message_set(RAM,0x400+RAM[15+offset3+scene_depth*16]);
  1248.                 }
  1249.                 break;
  1250.             }
  1251.         }
  1252.     }
  1253.     for(loop=object_list;loop<(object_list+object_count*2);loop+=2)
  1254.     {
  1255.         loop2=read32(RAM,0xB9E6C8+(unsigned short)((RAM[loop]<<8)|RAM[loop+1])*8);
  1256.         for(loop3=0x12F70;loop3<0x18F30;loop3+=0x10)
  1257.         {
  1258.             if(read32(RAM,loop3)==loop2)
  1259.             {
  1260.                 printf("%08X %s\n",loop,pointers[(loop3-0x12F70)/0x10]);
  1261.                 break;
  1262.             }
  1263.         }
  1264.     }
  1265.     return;
  1266.     majora:
  1267.     for(scene_depth=0;scene_depth<count2;scene_depth+=1)
  1268.     {
  1269.         for(offset=0x1AD;offset<0x3EC;offset+=1)
  1270.         {
  1271.             if((unsigned short)(((RAM[offset3+scene_depth*16]&0xF)<<8)|RAM[1+offset3+scene_depth*16])==zenum_add[offset])
  1272.             {
  1273.                 printf("%08X %s\n",(offset3+scene_depth*16),zenum_sym[offset]);
  1274.                 switch(zenum_add[offset])
  1275.                 {
  1276.                     case 0x26:
  1277.                         if(RAM[15+offset3+scene_depth*16]==9||RAM[15+offset3+scene_depth*16]==10)
  1278.                         {
  1279.                             message_set(RAM,0x300+RAM[14+offset3+scene_depth*16]);
  1280.                         }
  1281.                         break;
  1282.                     case 0xA8:
  1283.                         message_set(RAM,0x300+(unsigned short)((RAM[14+offset3+scene_depth*16]<<8)|RAM[15+offset3+scene_depth*16]));
  1284.                         break;
  1285.                     case 0x146:
  1286.                         message_set(RAM,RAM[15+offset3+scene_depth*16]);
  1287.                         break;
  1288.                     case 0x1D7:
  1289.                         message_set(RAM,RAM[15+offset3+scene_depth*16]);
  1290.                 }
  1291.                 break;
  1292.             }
  1293.         }
  1294.     }  
  1295. }
  1296.  
  1297. int ovl_funcs[4]={0}, ovl_tracker;
  1298.  
  1299. int main(int argc, char **argv)
  1300. {
  1301.     const char names[32][3]=
  1302.     {
  1303.         "r0", "at", "v0", "v1",
  1304.         "a0", "a1", "a2", "a3",
  1305.         "t0", "t1", "t2", "t3",
  1306.         "t4", "t5", "t6", "t7",
  1307.         "s0", "s1", "s2", "s3",
  1308.         "s4", "s5", "s6", "s7",
  1309.         "t8", "t9", "k0", "k1",
  1310.         "gp", "sp", "fp", "ra"
  1311.     };
  1312.     char choice[2], filename[9], code[5]={0};
  1313.     FILE *ROM=fopen(argv[1],"rb");
  1314.     unsigned int CPU[32]={0}, inst=0, tgt;
  1315.     int addr_db[8192],base[2]={0x1000, 0x738C0},num=0,func_end=0,sum=0,addr,func,pc,loop;
  1316.     int zenum_add[8192],prev_tgt=0,znum=0,add,ext; //426 MM
  1317.     char LUIWATCH[32]={0},symb[64],symb_db[8192][64],zenum_sym[8192][128],actor[33],mode=CART;
  1318.     fseek(ROM,0,SEEK_END);
  1319.     int end=ftell(ROM);
  1320.     fseek(ROM,0,SEEK_SET);
  1321.     unsigned char *RAM=malloc(end);
  1322.     fread(RAM,1,end,ROM);
  1323.     fclose(ROM);
  1324.     if(read32(RAM,0x3C)==0x5A4C450F)
  1325.     {
  1326.         RAM[0xB8D721]=0xBC;RAM[0xB8D722]=0xFA;RAM[0xB8D723]=0xC0;
  1327.         RAM[0xB8D725]=0xBD;RAM[0xB8D726]=0x2B;RAM[0xB8D727]=0x20;
  1328.         RAM[0xB8D729]=0x80;RAM[0xB8D72A]=0x0B;RAM[0xB8D72B]=0x90;
  1329.  
  1330.         RAM[0xB8D461]=0xBC;RAM[0xB8D462]=0xEF;RAM[0xB8D463]=0x30;
  1331.         RAM[0xB8D465]=0xBC;RAM[0xB8D466]=0xFA;RAM[0xB8D467]=0xC0;
  1332.         RAM[0xB8D469]=0x80;
  1333.  
  1334.         RAM[0xB8D4A1]=0xBD;RAM[0xB8D4A2]=0x2B;RAM[0xB8D4A3]=0x20;
  1335.         RAM[0xB8D4A5]=0xBD;RAM[0xB8D4A6]=0x2C;RAM[0xB8D4A7]=0x70;
  1336.         RAM[0xB8D4A9]=0x80;RAM[0xB8D4AA]=0x3B;RAM[0xB8D4AB]=0xF0;
  1337.  
  1338.         RAM[0xB8D4E1]=0xBD;RAM[0xB8D4E2]=0x2C;RAM[0xB8D4E3]=0x70;
  1339.         RAM[0xB8D4E5]=0xBE;RAM[0xB8D4E6]=0x27;RAM[0xB8D4E7]=0x30;
  1340.         RAM[0xB8D4E9]=0x80;RAM[0xB8D4EA]=0x3D;RAM[0xB8D4EB]=0x40;
  1341.  
  1342.         RAM[0xB8D501]=0xC2;RAM[0xB8D502]=0x79;RAM[0xB8D503]=0x40;
  1343.         RAM[0xB8D505]=0xC2;RAM[0xB8D506]=0xE4;RAM[0xB8D507]=0x20;
  1344.         RAM[0xB8D509]=0x85;RAM[0xB8D50A]=0x8B;RAM[0xB8D50B]=0x70;
  1345.  
  1346.         RAM[0xB8D6E1]=0xBE;RAM[0xB8D6E2]=0x27;RAM[0xB8D6E3]=0x30;
  1347.         RAM[0xB8D6E5]=0xC0;RAM[0xB8D6E6]=0x10;RAM[0xB8D6E7]=0xB0;
  1348.         RAM[0xB8D6E9]=0x81;RAM[0xB8D6EA]=0x38;RAM[0xB8D6EB]=0x20;
  1349.  
  1350.         RAM[0xB8D441]=0xC0;RAM[0xB8D442]=0x10;RAM[0xB8D443]=0xB0;
  1351.         RAM[0xB8D445]=0xC2;RAM[0xB8D446]=0x79;RAM[0xB8D447]=0x40;
  1352.         RAM[0xB8D449]=0x83;RAM[0xB8D44A]=0x22;RAM[0xB8D44B]=0x10;
  1353.         addr=0xBE80;
  1354.         for(loop=0;loop<1532;loop+=1)
  1355.         {
  1356.             add=0;
  1357.             while(RAM[addr]!=0)
  1358.             {
  1359.                 pointers[loop][add]=RAM[addr];
  1360.                 add+=1;
  1361.                 addr+=1;
  1362.             }
  1363.             while(RAM[addr]==0)
  1364.             {
  1365.                 addr+=1;
  1366.             }
  1367.         }
  1368.     }
  1369.     if(read32(RAM,0x3C)==0x5A535001)
  1370.     {
  1371.         RAM[0xDD5A51]=0xE4;RAM[0xDD5A52]=0x64;RAM[0xDD5A53]=0x60;
  1372.         RAM[0xDD5A55]=0xE7;RAM[0xDD5A56]=0xFF;RAM[0xDD5A57]=0x20;
  1373.         RAM[0xDD5A59]=0x83;RAM[0xDD5A5A]=0x3E;RAM[0xDD5A5B]=0xD0;
  1374.  
  1375.         RAM[0xDD5C11]=0xE1;RAM[0xDD5C12]=0x34;RAM[0xDD5C13]=0x20;
  1376.         RAM[0xDD5C15]=0xE1;RAM[0xDD5C16]=0x6B;RAM[0xDD5C17]=0x30;
  1377.         RAM[0xDD5C19]=0x80;RAM[0xDD5C1A]=0x0E;RAM[0xDD5C1B]=0x20;
  1378.  
  1379.         RAM[0xDD5CB1]=0xE1;RAM[0xDD5CB2]=0x26;
  1380.         RAM[0xDD5CB5]=0xE1;RAM[0xDD5CB6]=0x34;RAM[0xDD5CB7]=0x20;
  1381.         RAM[0xDD5CB9]=0x80;
  1382.  
  1383.         RAM[0xDD5E31]=0xE1;RAM[0xDD5E32]=0x6B;RAM[0xDD5E33]=0x30;
  1384.         RAM[0xDD5E35]=0xE1;RAM[0xDD5E36]=0x6E;
  1385.         RAM[0xDD5E39]=0x80;RAM[0xDD5E3A]=0x45;RAM[0xDD5E3B]=0x30;
  1386.  
  1387.         RAM[0xDD5EB1]=0xE1;RAM[0xDD5EB2]=0x6E;
  1388.         RAM[0xDD5EB5]=0xE2;RAM[0xDD5EB6]=0xAE;RAM[0xDD5EB7]=0xC0;
  1389.         RAM[0xDD5EB9]=0x80;RAM[0xDD5EBA]=0x48;
  1390.  
  1391.         RAM[0xDD5EF1]=0xE2;RAM[0xDD5EF2]=0xAE;RAM[0xDD5EF3]=0xC0;
  1392.         RAM[0xDD5EF5]=0xE2;RAM[0xDD5EF6]=0xC6;RAM[0xDD5EF7]=0xA0;
  1393.         RAM[0xDD5EF9]=0x81;RAM[0xDD5EFA]=0x88;RAM[0xDD5EFB]=0xF0;
  1394.  
  1395.         RAM[0xDD5F11]=0xE2;RAM[0xDD5F12]=0xC6;RAM[0xDD5F13]=0xA0;
  1396.         RAM[0xDD5F15]=0xE4;RAM[0xDD5F16]=0x64;RAM[0xDD5F17]=0x60;
  1397.         RAM[0xDD5F19]=0x81;RAM[0xDD5F1A]=0xA0;RAM[0xDD5F1B]=0xD0;
  1398.     }
  1399.     if(RAM[0]!=0x80){mode=DISK;}
  1400.     if(mode==CART)
  1401.     {
  1402.         code[0]=RAM[0x3C];
  1403.         code[1]=RAM[0x3D];
  1404.         code[2]=RAM[0x3E];
  1405.         code[3]=RAM[0x3F];
  1406.         if(code[0]==0)
  1407.         {
  1408.             code[0]=RAM[0x20];
  1409.             code[1]=RAM[0x21];
  1410.             code[2]=RAM[0x22];
  1411.             code[3]=RAM[0x23];
  1412.             if(read32(RAM,0x10)==0xA04237B9)
  1413.             {
  1414.                 code[0]=0x57;
  1415.                 code[1]=0x69;
  1416.                 code[2]=0x6C;
  1417.                 code[3]=0x64;
  1418.             }
  1419.             if(read32(RAM,0x20)==0x53796432&&read32(RAM,0x10)!=0x80A78080)
  1420.             {
  1421.                 return -1;
  1422.             }
  1423.             goto after;
  1424.         }
  1425.     }
  1426.     else
  1427.     {
  1428.         code[0]=RAM[0x43670];
  1429.         code[1]=RAM[0x43671];
  1430.         code[2]=RAM[0x43672];
  1431.         code[3]=RAM[0x43673];
  1432.         if(code[0]==0)
  1433.         {
  1434.             if(read32(RAM,0x738C8)==0x25085690)
  1435.             {
  1436.                 code[0]=0x44;
  1437.                 code[1]=0x53;
  1438.                 code[2]=0x4D;
  1439.                 code[3]=0x4A;
  1440.             }
  1441.             else
  1442.             {
  1443.                 code[0]=0x54;
  1444.                 code[1]=0x45;
  1445.                 code[2]=0x53;
  1446.                 code[3]=0x54;
  1447.             }
  1448.         }
  1449.         goto after;
  1450.     }
  1451.     if(code[3]<0xA)
  1452.     {
  1453.         code[3]+=0x30;
  1454.     }
  1455.     else
  1456.     {
  1457.         code[3]+=0x37;
  1458.     }
  1459.     after:
  1460.     if(code[0]==0){return -1;}
  1461.     sprintf(filename,"%s.txt",code);
  1462.     FILE *symbols=fopen(filename,"r");
  1463.     while(!feof(symbols))
  1464.     {
  1465.         fscanf(symbols,"%x %s\n",&addr,symb);
  1466.         addr_db[num]=addr;
  1467.         strcpy(symb_db[num],symb);
  1468.         num+=1;
  1469.     }
  1470.     fclose(symbols);
  1471.     if((read32(RAM,0x3C)>>24)==0x5A)
  1472.     {
  1473.         FILE *zenum=fopen("znum.txt","r");
  1474.         while(!feof(zenum))
  1475.         {
  1476.             fscanf(zenum,"%x %s\n",&addr,symb);
  1477.             zenum_add[znum]=addr;
  1478.             strcpy(zenum_sym[znum],symb);
  1479.             znum+=1;
  1480.         }
  1481.         fclose(zenum);
  1482.     }
  1483.     if(mode==CART)
  1484.     {
  1485.         for(loop=0x40;loop<0x1000;loop+=1)
  1486.         {
  1487.             sum+=RAM[loop];
  1488.         }
  1489.         pc=read32(RAM,8)&0x1FFFFFFF;
  1490.         if(sum==0x357D0){pc-=0x100000;}
  1491.         if(sum==0x371CC){pc-=0x200000;}
  1492.     }
  1493.     else
  1494.     {
  1495.         pc=read32(RAM,0x1C)&0x1FFFFFFF;
  1496.         if(pc==0)
  1497.         {
  1498.             pc=read32(RAM,0x9A2C)&0x1FFFFFFF;
  1499.         }
  1500.     }
  1501.     unsigned char *REG=malloc(0x40000);
  1502.     again:
  1503.     add=0;
  1504.     if(ovl_funcs[0]>0||ovl_funcs[1]>0||ovl_funcs[2]>0||ovl_funcs[3]>0)
  1505.     {
  1506.         ovl_tracker+=1;
  1507.         while(ovl_funcs[ovl_tracker]==0)
  1508.         {
  1509.             ovl_tracker+=1;
  1510.         }
  1511.         if(ovl_tracker<4)
  1512.         {
  1513.             func=ovl_funcs[ovl_tracker];
  1514.             goto func_len;
  1515.         }
  1516.         ovl_funcs[0]=0;
  1517.         ovl_funcs[1]=0;
  1518.         ovl_funcs[2]=0;
  1519.         ovl_funcs[3]=0;
  1520.         ovl_tracker=0;
  1521.         goto choose;
  1522.     }
  1523.     printf("Where? ");
  1524.     scanf("%x",&func);
  1525.     if(read32(RAM,0x3C)==0x5A4C450F||read32(RAM,0x3C)==0x5A535001)
  1526.     {
  1527.         if(func<113)
  1528.         {
  1529.         scene(RAM,func,zenum_add,zenum_sym);
  1530.         goto choose;
  1531.         }
  1532.         if(func>=0x1281CF0)
  1533.         {
  1534.             ovl_funcs[0]=0;
  1535.             ovl_funcs[1]=0;
  1536.             ovl_funcs[2]=0;
  1537.             ovl_funcs[3]=0;
  1538.             ovl_tracker=0;
  1539.             loop=((RAM[func]<<8)|RAM[1+func])&0xFFF;
  1540.             switch(RAM[0x3F])
  1541.             {
  1542.                 case 1:
  1543.                     if(loop<=0x2B1)
  1544.                     {
  1545.                         addr=read32(RAM,0xDD5A64+0x20*loop)&0xffffff;
  1546.                         add=read32(RAM,0xDD5A50+0x20*loop);
  1547.                         add-=(read32(RAM,0xDD5A58+0x20*loop)&0xffffff);
  1548.                         addr+=add+0x10;
  1549.                         ovl_funcs[0]=read32(RAM,addr+12)&0xffffff;
  1550.                         ovl_funcs[1]=read32(RAM,addr)&0xffffff;
  1551.                         ovl_funcs[2]=read32(RAM,addr+4)&0xffffff;
  1552.                         ovl_funcs[3]=read32(RAM,addr+8)&0xffffff;
  1553.                         while(ovl_funcs[ovl_tracker]==0)
  1554.                         {
  1555.                             ovl_tracker+=1;
  1556.                         }
  1557.                         if(ovl_funcs[0]>0){ovl_funcs[0]+=add;}
  1558.                         if(ovl_funcs[1]>0){ovl_funcs[1]+=add;}
  1559.                         if(ovl_funcs[2]>0){ovl_funcs[2]+=add;}
  1560.                         if(ovl_funcs[3]>0){ovl_funcs[3]+=add;}
  1561.                     }
  1562.                     break;
  1563.                 case 15:
  1564.                     if(loop<=0x1D6)
  1565.                     {
  1566.                         addr=read32(RAM,0xB8D454+0x20*loop)&0xffffff;
  1567.                         add=read32(RAM,0xB8D440+0x20*loop);
  1568.                         add-=(read32(RAM,0xB8D448+0x20*loop)&0xffffff);
  1569.                         addr+=add+0x10;
  1570.                         ovl_funcs[0]=read32(RAM,addr+12)&0xffffff;
  1571.                         ovl_funcs[1]=read32(RAM,addr)&0xffffff;
  1572.                         ovl_funcs[2]=read32(RAM,addr+4)&0xffffff;
  1573.                         ovl_funcs[3]=read32(RAM,addr+8)&0xffffff;
  1574.                         while(ovl_funcs[ovl_tracker]==0)
  1575.                         {
  1576.                             ovl_tracker+=1;
  1577.                         }
  1578.                         if(ovl_funcs[0]>0){ovl_funcs[0]+=add;}
  1579.                         if(ovl_funcs[1]>0){ovl_funcs[1]+=add;}
  1580.                         if(ovl_funcs[2]>0){ovl_funcs[2]+=add;}
  1581.                         if(ovl_funcs[3]>0){ovl_funcs[3]+=add;}
  1582.                     }
  1583.             }
  1584.             add=0;
  1585.             if(ovl_funcs[ovl_tracker]>0)
  1586.             {
  1587.                 func=ovl_funcs[ovl_tracker];
  1588.             }
  1589.         }
  1590.     }
  1591.     func_len:
  1592.     if(ovl_funcs[ovl_tracker]>0)
  1593.     {
  1594.         switch(ovl_tracker)
  1595.         {
  1596.             case 0:
  1597.                 printf("\nactor->draw_proc\n");
  1598.                 break;
  1599.             case 1:
  1600.                 printf("\nactor->constract_proc\n");
  1601.                 break;
  1602.             case 2:
  1603.                 printf("\nactor->destruct_proc\n");
  1604.                 break;
  1605.             case 3:
  1606.                 printf("\nactor->move_proc\n");
  1607.                
  1608.         }
  1609.         system("pause");
  1610.     }
  1611.     if((func&3)!=0){goto again;}
  1612.     if(func<0x40||func>=end){goto again;}
  1613.     if(read32(RAM,0x3C)==0x5A4C450F||read32(RAM,0x3C)==0x5A535001)
  1614.     {
  1615.         add=ovl_adapt(RAM,REG,func,read32(RAM,0x3C));
  1616.         if(add>0)
  1617.         {
  1618.             ext=0;
  1619.             if(read32(RAM,0x3C)==0x5A4C450F)
  1620.             {
  1621.                 goto ZL;
  1622.             }
  1623.             if(func>=0xF94580&&func<0x10FB660)
  1624.             {
  1625.                 inst=0xDFCDDC;
  1626.                 goto skip;
  1627.             }
  1628.             for(addr=0;addr<0x2B2;addr+=1)
  1629.             {
  1630.                 if(func>=read32(RAM,0xDD5A50+0x20*addr)&&func<read32(RAM,0xDD5A54+0x20*addr))
  1631.                 {
  1632.                     inst=0xBDE540+read32(RAM,0xDD5A68+0x20*addr);
  1633.                     break;
  1634.                 }
  1635.             }
  1636.             goto skip;
  1637.             ZL:
  1638.             if(func>=0xD583E0&&func<0xD66150)
  1639.             {
  1640.                 inst=0xCD60;
  1641.                 goto skip;
  1642.             }
  1643.             for(addr=0;addr<0x1D7;addr+=1)
  1644.             {
  1645.                 if(func>=read32(RAM,0xB8D440+0x20*addr)&&func<read32(RAM,0xB8D444+0x20*addr))
  1646.                 {
  1647.                     inst=0xA771A0+read32(RAM,0xB8D458+0x20*addr);
  1648.                     break;
  1649.                 }
  1650.             }
  1651.             skip:
  1652.             addr=1;
  1653.             while(addr!=0)
  1654.             {
  1655.                 addr=RAM[inst+ext];
  1656.                 actor[ext]=addr;
  1657.                 ext+=1;
  1658.             }
  1659.         }
  1660.     }
  1661.     while(inst!=0x03E00008)
  1662.     {
  1663.         inst=read32(RAM,func+func_end);
  1664.         func_end+=4;
  1665.         if(inst==0x02A00008){break;}
  1666.     }
  1667.     func_end+=4;
  1668.     for(addr=0;addr<(func_end/4);addr+=1)
  1669.     {
  1670.         ext=0;
  1671.         tgt=func+addr*4;
  1672.         inst=read32(RAM,tgt);
  1673.         if(inst!=0&&op(inst)!=J&&op(inst)!=JAL&&op(inst)!=LUI&&op(inst)!=BNEL)
  1674.         {
  1675.             printf("%08X ",tgt);
  1676.         }
  1677.         switch(op(inst))
  1678.         {
  1679.             case SPECIAL:
  1680.                 switch(funct(inst))
  1681.                 {
  1682.                     case OR:
  1683.                         tgt=rd(inst);
  1684.                         CPU[tgt]=CPU[rs(inst)]|CPU[rt(inst)];
  1685.                         if(tgt>=S0&&tgt<T8)
  1686.                         {
  1687.                         if(rs(inst)>=A0&&rs(inst)<T0&&rt(inst)==R0)
  1688.                         {
  1689.                             if(read32(RAM,0x3C)==0x5A4C450F)
  1690.                             {
  1691.                                 CPU[tgt]=0x80212020;
  1692.                             }
  1693.                         }
  1694.                         }
  1695.                         for(loop=0;loop<num;loop+=1)
  1696.                         {
  1697.                             if(addr_db[loop]==CPU[tgt])
  1698.                             {
  1699.                                 if(CPU[tgt]>0xFFF&&tgt<T0)
  1700.                                 {
  1701.                                     printf("%s = %s\n",names[tgt],symb_db[loop]);
  1702.                                     break;
  1703.                                 }
  1704.                                 else if(CPU[tgt]>0xFFF&&tgt>=T0)
  1705.                                 {
  1706.                                     if(CPU[tgt]<0x80000000)
  1707.                                     {
  1708.                                         printf("%s = %s\n",names[tgt],symb_db[loop]);
  1709.                                         break;
  1710.                                     }
  1711.                                 }
  1712.                                 else
  1713.                                 {
  1714.                                     if(tgt<T0)
  1715.                                     {
  1716.                                         printf("%s = 0x%X\n",names[tgt],CPU[tgt]);
  1717.                                         break;
  1718.                                     }
  1719.                                     else
  1720.                                     {
  1721.                                         if(CPU[tgt]<0x80000000)
  1722.                                         {
  1723.                                             printf("%08X\n",inst);
  1724.                                             break;
  1725.                                         }
  1726.                                     }
  1727.                                 }
  1728.                             }
  1729.                         }
  1730.                         if(loop==num)
  1731.                         {
  1732.                             if(tgt<T0)
  1733.                             {
  1734.                                 printf("%s = 0x%X\n",names[tgt],CPU[tgt]);
  1735.                             }
  1736.                             else
  1737.                             {
  1738.                                 printf("%08X\n",inst);
  1739.                             }
  1740.                         }
  1741.                         break;
  1742.                     default:
  1743.                         if(inst!=0)
  1744.                         {
  1745.                             printf("%08X\n",inst);
  1746.                         }
  1747.                         break;
  1748.                 }
  1749.                 break;
  1750.             case J:
  1751.             case JAL:
  1752.                 tgt=(unsigned int)((inst&0x03ffffff)<<2);
  1753.                 if(tgt<0x800000&&prev_tgt>=0x800000)
  1754.                 {
  1755.                     system("pause");
  1756.                 }
  1757.                 prev_tgt=tgt;
  1758.                 if(read32(RAM,0x3C)==0x242C343C&&tgt>=0x510000)
  1759.                 {
  1760.                     if(read32(RAM,0x738C8)==0x25085690)
  1761.                     {
  1762.                         ext=1;
  1763.                         tgt-=0x3E70B0;
  1764.                     }
  1765.                     else
  1766.                     {
  1767.                         tgt-=pc;
  1768.                         tgt+=base[mode];
  1769.                     }
  1770.                 }
  1771.                 else if(read32(RAM,0x3C)==0x41464A00&&tgt>=0x051A80) //Doubutsu no Mori (Japan)
  1772.                 {
  1773.                     if(tgt>>24==4)
  1774.                     {
  1775.                         if(func>=0x675720){tgt-=0x38E0090;}
  1776.                         else{tgt-=0x3FEA0C0;}
  1777.                     }
  1778.                     else
  1779.                     {
  1780.                         ext=1;
  1781.                         tgt+=0x623CA0;
  1782.                     }
  1783.                 }
  1784.                 else if(read32(RAM,0x3C)==0x46444500&&tgt>=0x4001000) //Flying Dragon
  1785.                 {
  1786.                     tgt-=0x3F803E0;
  1787.                 }
  1788.                 else if(read32(RAM,0x3C)==0x465A4A00&&tgt>=0x4001000) //F-Zero X
  1789.                 {
  1790.                     tgt-=0x3F9F620;
  1791.                 }
  1792.                 else if(read32(RAM,0x3C)==0x47354500&&tgt>=0x4001000) //Mystical Ninja Starring Goemon
  1793.                 {
  1794.                     tgt-=0x3FADE00;
  1795.                 }
  1796.                 else if(read32(RAM,0x3C)==0x47414500&&tgt>=0x4001000) //Deadly Arts
  1797.                 {
  1798.                     tgt-=0x3FD1BE0;
  1799.                 }
  1800.                 else if(read32(RAM,0x3C)==0x474D4500&&tgt>=0x4001000) //Goemon's Great Adventure
  1801.                 {
  1802.                     tgt-=0x3FDBF40;
  1803.                 }
  1804.                 else if(read32(RAM,0x3C)==0x4B414500&&tgt>=0x4001000) //Fighter's Destiny
  1805.                 {
  1806.                     tgt-=0x3FB88A0;
  1807.                 }
  1808.                 else if(read32(RAM,0x3C)==0x4B544A00&&tgt>=0x280000) //Mario Kart 64 (J) (V1.0) [!]
  1809.                 {
  1810.                     if(tgt>>24==4)
  1811.                     {
  1812.                         tgt-=0x3F26B70;
  1813.                     }
  1814.                     else
  1815.                     {
  1816.                         ext=1;
  1817.                         tgt-=0x15BF90;    //map_ram(0x280000, 0x124070, 0x007490);
  1818.                         if(tgt+0x15BF90>=0x28DF00)
  1819.                         {
  1820.                             ext=2;
  1821.                             tgt-=0x39FB0; //map_ram(0x28DF00, 0x0F7FC0, 0x02C0B0);
  1822.                         }
  1823.                     }
  1824.                 }
  1825.                 else if(read32(RAM,0x3C)==0x4D454500&&tgt>=0x4001000) //Mace - The Dark Age
  1826.                 {
  1827.                     tgt-=0x3F85C00;
  1828.                 }
  1829.                 else if(read32(RAM,0x3C)==0x4D514A00&&tgt>=0x0DC4E0) //Mario Story (Japan)
  1830.                 {
  1831.                     if(tgt>>24==4)
  1832.                     {
  1833.                         tgt-=0x4000440;
  1834.                     }
  1835.                     else
  1836.                     {
  1837.                         ext=1;
  1838.                         tgt-=0x066B50;               //map_ram(0x0DC4E0, 0x075990, 0x030600);
  1839.                         if(tgt+0x066B50>=0x10F890)
  1840.                         {
  1841.                             ext=2;
  1842.                             tgt-=0x002DB0;           //map_ram(0x10F890, 0x0A5F90, 0x0037E0);
  1843.                             if(tgt+0x069900>=0x1148E0)
  1844.                             {
  1845.                                 ext=3;
  1846.                                 tgt-=0x001870;       //map_ram(0x1148E0, 0x0A9770, 0x041A30);
  1847.                                 if(tgt+0x06B170>=0x2C3000)
  1848.                                 {
  1849.                                     ext=4;
  1850.                                     tgt-=0x16CCF0;   //map_ram(0x2C3000, 0x0EB1A0, 0x017480);
  1851.                                 }
  1852.                             }
  1853.                         }
  1854.                     }
  1855.                 }
  1856.                 else if(read32(RAM,0x3C)==0x534D4A00&&tgt>=0x378800) //Super Mario 64 (J) [!]
  1857.                 {
  1858.                     if(tgt>>24==4)
  1859.                     {
  1860.                         tgt-=0x3F1BC90;
  1861.                     }
  1862.                     else
  1863.                     {
  1864.                         ext=1;
  1865.                         tgt-=0x2845F0; //map_ram(0x378800, 0x0F4210, 0x013490);
  1866.                     }
  1867.                 }
  1868.                 else if(read32(RAM,0x3C)==0x57414500&&tgt>=0x4001000) //War Gods
  1869.                 {
  1870.                     tgt-=0x3F63240;
  1871.                 }
  1872.                 else if(read32(RAM,0x3C)==0x574F4500&&tgt>=0x4001000) //World Driver Championship
  1873.                 {
  1874.                     tgt-=0x3F83D00;
  1875.                 }
  1876.                 else if(read32(RAM,0x3C)==0x5A4C450F&&tgt>=0x01CE60) //ZELOOTMA
  1877.                 {
  1878.                     if(tgt>>24==4)
  1879.                     {
  1880.                         if(func>=0xA94000){tgt-=0x3477DA0;}
  1881.                         else{tgt-=0x3FF7090;}
  1882.                     }
  1883.                     else
  1884.                     {
  1885.                         if(add>0&&tgt>=0x800000)
  1886.                         {
  1887.                             tgt+=add;
  1888.                         }
  1889.                         else
  1890.                         {
  1891.                             ext=1;
  1892.                             tgt+=0xA771A0;
  1893.                         }
  1894.                     }
  1895.                 }
  1896.                 else if(read32(RAM,0x3C)==0x5A4C4A00&&tgt>=0x0110A0) //Zelda no Densetsu - Toki no Ocarina (Japan)
  1897.                 {
  1898.                     if(tgt>>24==4)
  1899.                     {
  1900.                         tgt-=0x34A80E0;
  1901.                     }
  1902.                     else
  1903.                     {
  1904.                         ext=1;
  1905.                         tgt+=0xA75F60;
  1906.                     }
  1907.                 }
  1908.                 else if(read32(RAM,0x3C)==0x5A535001&&tgt>=0x0B6AC0) //mm_debug
  1909.                 {
  1910.                     if(tgt>>24==4)
  1911.                     {
  1912.                         tgt-=0x322FA50;
  1913.                     }
  1914.                     else
  1915.                     {
  1916.                         if(add>0&&tgt>=0x800000)
  1917.                         {
  1918.                             tgt+=add;
  1919.                         }
  1920.                         else
  1921.                         {
  1922.                             ext=1;
  1923.                             tgt+=0xBDE540;
  1924.                         }
  1925.                     }
  1926.                 }
  1927.                 else
  1928.                 {
  1929.                     tgt-=pc;
  1930.                     tgt+=base[mode];
  1931.                     if(func>=0xB8A210&&func<0xB8BAD0)   //S2DEX2
  1932.                     {
  1933.                         if(read32(RAM,0x3C)==0x5A4C450F)
  1934.                         {
  1935.                         if(tgt>=0x2A00)             //1E00 - 1FFF is static
  1936.                         {
  1937.                             tgt+=0xB88590;
  1938.                         }
  1939.                         if(tgt>=0x1C98&&tgt<0x22D0) //1180 - 16CF is static but
  1940.                         {                           //1098 doesn't have conflicts
  1941.                             tgt+=0xB88590;
  1942.                         }
  1943.                         }
  1944.                     }
  1945.                     if(func>=0xBCD0F0&&func<0xBCE720)   //F3DEX2
  1946.                     {
  1947.                         if(read32(RAM,0x3C)==0x5A4C450F)
  1948.                         {
  1949.                         if(tgt>=0x2380)             //1780 - 1FFF is static
  1950.                         {
  1951.                             tgt+=0xBCB470;
  1952.                         }
  1953.                         if(tgt>=0x1C00&&tgt<0x1D70) //1000 - 116F is ovl0, ovl1 and init
  1954.                         {
  1955.                             tgt+=0xBCC508;    //assume it's ovl1
  1956.                             if(tgt==0xBCE128) //fix 1020
  1957.                             {
  1958.                                 tgt-=0x98;    //(the only part of ovl0 J/JAL'd to)
  1959.                             }
  1960.                             if(tgt==0xBCE270) //fix 1168
  1961.                             {
  1962.                                 tgt-=0x1098;  //(the only part of init J/JAL'd to)
  1963.                             }
  1964.                         }
  1965.                         if(tgt>=0x1D70&&tgt<0x1ED8) //1170 - 12D7 is static
  1966.                         {
  1967.                             tgt+=0xBCB470;
  1968.                         }
  1969.                         if(tgt>=0x1ED8&&tgt<0x2380) //12D8 - 177F is ovl2 and ovl3
  1970.                         {
  1971.                             tgt+=0xBCC3A0;    //assume it's ovl2
  1972.                             if(tgt==0xBCE2C0) //fix 1320
  1973.                             {
  1974.                                 tgt-=0xF30;   //(the only part of ovl3 J/JAL'd to)
  1975.                             }
  1976.                         }
  1977.                         }
  1978.                     }
  1979.                 }
  1980.                 ext=0;
  1981.                 if(read32(RAM,0x3C)==0x5A4C450F)
  1982.                 {
  1983.                     switch(tgt)
  1984.                     {
  1985.                         case 0xaa1b94:
  1986.                             for(loop=0;loop<num;loop+=1)
  1987.                             {
  1988.                                 if(addr_db[loop]==tgt)
  1989.                                 {
  1990.                                     if(op(inst)==J){printf("J %s //",symb_db[loop]);}
  1991.                                     else{printf("JAL <%s> //",symb_db[loop]);}
  1992.                                     break;
  1993.                                 }
  1994.                             }
  1995.                             if(loop==num)
  1996.                             {
  1997.                                 if(op(inst)==J){printf("J %08X",tgt);}
  1998.                                 else{printf("JAL %08X",tgt);}
  1999.                                 if(add>0&&tgt>=func-0x30000)
  2000.                                 {
  2001.                                     printf(" //%s",actor);
  2002.                                 }
  2003.                                 if(ext>0)
  2004.                                 {
  2005.                                     printf(" //External file %d",ext);
  2006.                                 }
  2007.                             }
  2008.                             ext=1;
  2009.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A2))
  2010.                             {
  2011.                                 CPU[A2]=read32(RAM,func+(addr+1)*4)&0xffff;
  2012.                             }
  2013.                             for(loop=1004;loop<znum;loop+=1)
  2014.                             {
  2015.                                 if(zenum_add[loop]==CPU[A2]||(zenum_add[loop]-0x800)==CPU[A2])
  2016.                                 {
  2017.                                     if(zenum_add[loop]==CPU[A2])
  2018.                                     {
  2019.                                         printf(" %s\n",zenum_sym[loop]);
  2020.                                     }
  2021.                                     else if((zenum_add[loop]-0x800)==CPU[A2])
  2022.                                     {
  2023.                                         printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
  2024.                                     }
  2025.                                     break;
  2026.                                 }
  2027.                             }
  2028.                             system("pause");
  2029.                             break;
  2030.                         case 0xAA697C:
  2031.                         case 0xAA69C8:
  2032.                         case 0xAA6A90:
  2033.                         case 0xAA6ABC:
  2034.                         case 0xAA6AE8:
  2035.                         case 0xAA6B14:
  2036.                         case 0xAEFAB4:
  2037.                         case 0xB6B50C:
  2038.                             for(loop=0;loop<num;loop+=1)
  2039.                             {
  2040.                                 if(addr_db[loop]==tgt)
  2041.                                 {
  2042.                                     if(op(inst)==J){printf("J %s //",symb_db[loop]);}
  2043.                                     else{printf("JAL <%s> //",symb_db[loop]);}
  2044.                                     break;
  2045.                                 }
  2046.                             }
  2047.                             if(loop==num)
  2048.                             {
  2049.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2050.                                 else{printf("JAL %08X",tgt);}
  2051.                                 if(add>0&&tgt>=func-0x30000)
  2052.                                 {
  2053.                                     printf(" //%s",actor);
  2054.                                 }
  2055.                                 if(ext>0)
  2056.                                 {
  2057.                                     printf(" //External file %d",ext);
  2058.                                 }
  2059.                             }
  2060.                             ext=1;
  2061.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A1))
  2062.                             {
  2063.                                 CPU[A1]=read32(RAM,func+(addr+1)*4)&0xffff;
  2064.                             }
  2065.                             for(loop=1004;loop<znum;loop+=1)
  2066.                             {
  2067.                                 if(zenum_add[loop]==CPU[A1]||(zenum_add[loop]-0x800)==CPU[A1])
  2068.                                 {
  2069.                                     if(zenum_add[loop]==CPU[A1])
  2070.                                     {
  2071.                                         printf(" %s\n",zenum_sym[loop]);
  2072.                                     }
  2073.                                     else if((zenum_add[loop]-0x800)==CPU[A1])
  2074.                                     {
  2075.                                         printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
  2076.                                     }
  2077.                                     break;
  2078.                                 }
  2079.                             }
  2080.                             system("pause");
  2081.                             break;
  2082.                         case 0xAE2C78:
  2083.                             for(loop=0;loop<num;loop+=1)
  2084.                             {
  2085.                                 if(addr_db[loop]==tgt)
  2086.                                 {
  2087.                                     if(op(inst)==J){printf("J %s //",symb_db[loop]);}
  2088.                                     else{printf("JAL <%s> //",symb_db[loop]);}
  2089.                                     break;
  2090.                                 }
  2091.                             }
  2092.                             if(loop==num)
  2093.                             {
  2094.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2095.                                 else{printf("JAL %08X",tgt);}
  2096.                                 if(add>0&&tgt>=func-0x30000)
  2097.                                 {
  2098.                                     printf(" //%s",actor);
  2099.                                 }
  2100.                                 if(ext>0)
  2101.                                 {
  2102.                                     printf(" //External file %d",ext);
  2103.                                 }
  2104.                             }
  2105.                             ext=1;
  2106.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A3))
  2107.                             {
  2108.                                 CPU[A3]=read32(RAM,func+(addr+1)*4)&0xffff;
  2109.                             }
  2110.                             for(loop=1004;loop<znum;loop+=1)
  2111.                             {
  2112.                                 if(zenum_add[loop]==CPU[A3]||(zenum_add[loop]-0x800)==CPU[A3])
  2113.                                 {
  2114.                                     if(zenum_add[loop]==CPU[A3])
  2115.                                     {
  2116.                                         printf(" %s\n",zenum_sym[loop]);
  2117.                                     }
  2118.                                     else if((zenum_add[loop]-0x800)==CPU[A3])
  2119.                                     {
  2120.                                         printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
  2121.                                     }
  2122.                                     break;
  2123.                                 }
  2124.                             }
  2125.                             system("pause");
  2126.                             break;
  2127.                         case 0xAEFA24:
  2128.                         case 0xAEFA6C:
  2129.                         case 0xB6E52C:
  2130.                             for(loop=0;loop<num;loop+=1)
  2131.                             {
  2132.                                 if(addr_db[loop]==tgt)
  2133.                                 {
  2134.                                     if(op(inst)==J){printf("J %s //",symb_db[loop]);}
  2135.                                     else{printf("JAL <%s> //",symb_db[loop]);}
  2136.                                     break;
  2137.                                 }
  2138.                             }
  2139.                             if(loop==num)
  2140.                             {
  2141.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2142.                                 else{printf("JAL %08X",tgt);}
  2143.                                 if(add>0&&tgt>=func-0x30000)
  2144.                                 {
  2145.                                     printf(" //%s",actor);
  2146.                                 }
  2147.                                 if(ext>0)
  2148.                                 {
  2149.                                     printf(" //External file %d",ext);
  2150.                                 }
  2151.                             }
  2152.                             ext=1;
  2153.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A0))
  2154.                             {
  2155.                                 CPU[A0]=read32(RAM,func+(addr+1)*4)&0xffff;
  2156.                             }
  2157.                             for(loop=1004;loop<znum;loop+=1)
  2158.                             {
  2159.                                 if(zenum_add[loop]==CPU[A0]||(zenum_add[loop]-0x800)==CPU[A0])
  2160.                                 {
  2161.                                     if(zenum_add[loop]==CPU[A0])
  2162.                                     {
  2163.                                         printf(" %s\n",zenum_sym[loop]);
  2164.                                     }
  2165.                                     else if((zenum_add[loop]-0x800)==CPU[A0])
  2166.                                     {
  2167.                                         printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
  2168.                                     }
  2169.                                     break;
  2170.                                 }
  2171.                             }
  2172.                             system("pause");
  2173.                             break;
  2174.                         case 0xAA90F0:
  2175.                             for(loop=0;loop<num;loop+=1)
  2176.                             {
  2177.                                 if(addr_db[loop]==tgt)
  2178.                                 {
  2179.                                     if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2180.                                     else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2181.                                     break;
  2182.                                 }
  2183.                             }
  2184.                             if(loop==num)
  2185.                             {
  2186.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2187.                                 else{printf("JAL %08X",tgt);}
  2188.                                 if(add>0&&tgt>=func-0x30000)
  2189.                                 {
  2190.                                     printf(" //%s",actor);
  2191.                                 }
  2192.                                 if(ext>0)
  2193.                                 {
  2194.                                     printf(" //External file %d",ext);
  2195.                                 }
  2196.                             }
  2197.                             ext=1;
  2198.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A2))
  2199.                             {
  2200.                                 CPU[A2]=read32(RAM,func+(addr+1)*4)&0xffff;
  2201.                             }
  2202.                             for(loop=0;loop<429;loop+=1)
  2203.                             {
  2204.                                 if(zenum_add[loop]==CPU[A2])
  2205.                                 {
  2206.                                     printf(" %s\n",zenum_sym[loop]);
  2207.                                     break;
  2208.                                 }
  2209.                             }
  2210.                             break;
  2211.                         case 0xAA95F8:
  2212.                             for(loop=0;loop<num;loop+=1)
  2213.                             {
  2214.                                 if(addr_db[loop]==tgt)
  2215.                                 {
  2216.                                     if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2217.                                     else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2218.                                     break;
  2219.                                 }
  2220.                             }
  2221.                             if(loop==num)
  2222.                             {
  2223.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2224.                                 else{printf("JAL %08X",tgt);}
  2225.                                 if(add>0&&tgt>=func-0x30000)
  2226.                                 {
  2227.                                     printf(" //%s",actor);
  2228.                                 }
  2229.                                 if(ext>0)
  2230.                                 {
  2231.                                     printf(" //External file %d",ext);
  2232.                                 }
  2233.                             }
  2234.                             ext=1;
  2235.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A3))
  2236.                             {
  2237.                                 CPU[A3]=read32(RAM,func+(addr+1)*4)&0xffff;
  2238.                             }
  2239.                             for(loop=0;loop<429;loop+=1)
  2240.                             {
  2241.                                 if(zenum_add[loop]==CPU[A3])
  2242.                                 {
  2243.                                     printf(" %s\n",zenum_sym[loop]);
  2244.                                     break;
  2245.                                 }
  2246.                             }
  2247.                             break;
  2248.                         case 0xB82820:
  2249.                             printf("%08X ",func+addr*4);
  2250.                             for(loop=0;loop<num;loop+=1)
  2251.                             {
  2252.                                 if(addr_db[loop]==tgt)
  2253.                                 {
  2254.                                     if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2255.                                     else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2256.                                     break;
  2257.                                 }
  2258.                             }
  2259.                             if(loop==num)
  2260.                             {
  2261.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2262.                                 else{printf("JAL %08X",tgt);}
  2263.                                 if(add>0&&tgt>=func-0x30000)
  2264.                                 {
  2265.                                     printf(" //%s",actor);
  2266.                                 }
  2267.                                 if(ext>0)
  2268.                                 {
  2269.                                     printf(" //External file %d",ext);
  2270.                                 }
  2271.                             }
  2272.                             ext=1;
  2273.                             printf("\n");
  2274.                             message_set(RAM,CPU[A1]);
  2275.                             break;
  2276.                         case 0xB828C0:
  2277.                             printf("%08X ",func+addr*4);
  2278.                             for(loop=0;loop<num;loop+=1)
  2279.                             {
  2280.                                 if(addr_db[loop]==tgt)
  2281.                                 {
  2282.                                     if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2283.                                     else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2284.                                     break;
  2285.                                 }
  2286.                             }
  2287.                             if(loop==num)
  2288.                             {
  2289.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2290.                                 else{printf("JAL %08X",tgt);}
  2291.                                 if(add>0&&tgt>=func-0x30000)
  2292.                                 {
  2293.                                     printf(" //%s",actor);
  2294.                                 }
  2295.                                 if(ext>0)
  2296.                                 {
  2297.                                     printf(" //External file %d",ext);
  2298.                                 }
  2299.                             }
  2300.                             ext=1;
  2301.                             if((read32(RAM,func+addr*4+4)>>16)==0x2405)
  2302.                             {
  2303.                                 CPU[A1]=imm(read32(RAM,func+addr*4+4));
  2304.                             }
  2305.                             if(op(read32(RAM,func+addr*4+4))==ANDI)
  2306.                             {
  2307.                                 CPU[rt(read32(RAM,func+addr*4+4))]=CPU[rs(read32(RAM,func+addr*4+4))]&imm(read32(RAM,func+addr*4+4));
  2308.                             }
  2309.                             printf("\n");
  2310.                             message_set(RAM,CPU[A1]);
  2311.                             break;
  2312.                     }
  2313.                 }
  2314.                 if(read32(RAM,0x3C)==0x5A535001)
  2315.                 {
  2316.                     switch(tgt)
  2317.                     {
  2318.                         case 0xCAA59C:
  2319.                         case 0xCAA628:
  2320.                         case 0xCAA730:
  2321.                         case 0xCAA758:
  2322.                         case 0xCAA780:
  2323.                         case 0xCAA7A8:
  2324.                         case 0xDC5900:
  2325.                             for(loop=0;loop<num;loop+=1)
  2326.                             {
  2327.                                 if(addr_db[loop]==tgt)
  2328.                                 {
  2329.                                     if(op(inst)==J){printf("J %s //",symb_db[loop]);}
  2330.                                     else{printf("JAL <%s> //",symb_db[loop]);}
  2331.                                     break;
  2332.                                 }
  2333.                             }
  2334.                             if(loop==num)
  2335.                             {
  2336.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2337.                                 else{printf("JAL %08X",tgt);}
  2338.                                 if(add>0&&tgt>=func-0x30000)
  2339.                                 {
  2340.                                     printf(" //%s",actor);
  2341.                                 }
  2342.                                 if(ext>0)
  2343.                                 {
  2344.                                     printf(" //External file %d",ext);
  2345.                                 }
  2346.                             }
  2347.                             ext=1;
  2348.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A1))
  2349.                             {
  2350.                                 CPU[A1]=read32(RAM,func+(addr+1)*4)&0xffff;
  2351.                             }
  2352.                             for(loop=1004;loop<znum;loop+=1)
  2353.                             {
  2354.                                 if(zenum_add[loop]==CPU[A1]||(zenum_add[loop]-0x800)==CPU[A1])
  2355.                                 {
  2356.                                     if(zenum_add[loop]==CPU[A1])
  2357.                                     {
  2358.                                         printf(" %s\n",zenum_sym[loop]);
  2359.                                     }
  2360.                                     else if((zenum_add[loop]-0x800)==CPU[A1])
  2361.                                     {
  2362.                                         printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
  2363.                                     }
  2364.                                     break;
  2365.                                 }
  2366.                             }
  2367.                             system("pause");
  2368.                             break;
  2369.                         case 0xCEC390:
  2370.                             for(loop=0;loop<num;loop+=1)
  2371.                             {
  2372.                                 if(addr_db[loop]==tgt)
  2373.                                 {
  2374.                                     if(op(inst)==J){printf("J %s //",symb_db[loop]);}
  2375.                                     else{printf("JAL <%s> //",symb_db[loop]);}
  2376.                                     break;
  2377.                                 }
  2378.                             }
  2379.                             if(loop==num)
  2380.                             {
  2381.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2382.                                 else{printf("JAL %08X",tgt);}
  2383.                                 if(add>0&&tgt>=func-0x30000)
  2384.                                 {
  2385.                                     printf(" //%s",actor);
  2386.                                 }
  2387.                                 if(ext>0)
  2388.                                 {
  2389.                                     printf(" //External file %d",ext);
  2390.                                 }
  2391.                             }
  2392.                             ext=1;
  2393.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A3))
  2394.                             {
  2395.                                 CPU[A3]=read32(RAM,func+(addr+1)*4)&0xffff;
  2396.                             }
  2397.                             for(loop=1004;loop<znum;loop+=1)
  2398.                             {
  2399.                                 if(zenum_add[loop]==CPU[A3]||(zenum_add[loop]-0x800)==CPU[A3])
  2400.                                 {
  2401.                                     if(zenum_add[loop]==CPU[A3])
  2402.                                     {
  2403.                                         printf(" %s\n",zenum_sym[loop]);
  2404.                                     }
  2405.                                     else if((zenum_add[loop]-0x800)==CPU[A3])
  2406.                                     {
  2407.                                         printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
  2408.                                     }
  2409.                                     break;
  2410.                                 }
  2411.                             }
  2412.                             system("pause");
  2413.                             break;
  2414.                         case 0xDC5808:
  2415.                         case 0xDC5868:
  2416.                             for(loop=0;loop<num;loop+=1)
  2417.                             {
  2418.                                 if(addr_db[loop]==tgt)
  2419.                                 {
  2420.                                     if(op(inst)==J){printf("J %s //",symb_db[loop]);}
  2421.                                     else{printf("JAL <%s> //",symb_db[loop]);}
  2422.                                     break;
  2423.                                 }
  2424.                             }
  2425.                             if(loop==num)
  2426.                             {
  2427.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2428.                                 else{printf("JAL %08X",tgt);}
  2429.                                 if(add>0&&tgt>=func-0x30000)
  2430.                                 {
  2431.                                     printf(" //%s",actor);
  2432.                                 }
  2433.                                 if(ext>0)
  2434.                                 {
  2435.                                     printf(" //External file %d",ext);
  2436.                                 }
  2437.                             }
  2438.                             ext=1;
  2439.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A0))
  2440.                             {
  2441.                                 CPU[A0]=read32(RAM,func+(addr+1)*4)&0xffff;
  2442.                             }
  2443.                             for(loop=1004;loop<znum;loop+=1)
  2444.                             {
  2445.                                 if(zenum_add[loop]==CPU[A0]||(zenum_add[loop]-0x800)==CPU[A0])
  2446.                                 {
  2447.                                     if(zenum_add[loop]==CPU[A0])
  2448.                                     {
  2449.                                         printf(" %s\n",zenum_sym[loop]);
  2450.                                     }
  2451.                                     else if((zenum_add[loop]-0x800)==CPU[A0])
  2452.                                     {
  2453.                                         printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
  2454.                                     }
  2455.                                     break;
  2456.                                 }
  2457.                             }
  2458.                             system("pause");
  2459.                             break;
  2460.                         case 0xCAD5F8:
  2461.                             for(loop=0;loop<num;loop+=1)
  2462.                             {
  2463.                                 if(addr_db[loop]==tgt)
  2464.                                 {
  2465.                                     if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2466.                                     else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2467.                                     break;
  2468.                                 }
  2469.                             }
  2470.                             if(loop==num)
  2471.                             {
  2472.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2473.                                 else{printf("JAL %08X",tgt);}
  2474.                                 if(add>0&&tgt>=func-0x30000)
  2475.                                 {
  2476.                                     printf(" //%s",actor);
  2477.                                 }
  2478.                                 if(ext>0)
  2479.                                 {
  2480.                                     printf(" //External file %d",ext);
  2481.                                 }
  2482.                             }
  2483.                             ext=1;
  2484.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A2))
  2485.                             {
  2486.                                 CPU[A2]=read32(RAM,func+(addr+1)*4)&0xffff;
  2487.                             }
  2488.                             for(loop=429;loop<1004;loop+=1)
  2489.                             {
  2490.                                 if(zenum_add[loop]==CPU[A2])
  2491.                                 {
  2492.                                     printf(" %s\n",zenum_sym[loop]);
  2493.                                     break;
  2494.                                 }
  2495.                             }
  2496.                             break;
  2497.                         case 0xCADB9C:
  2498.                             for(loop=0;loop<num;loop+=1)
  2499.                             {
  2500.                                 if(addr_db[loop]==tgt)
  2501.                                 {
  2502.                                     if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2503.                                     else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2504.                                     break;
  2505.                                 }
  2506.                             }
  2507.                             if(loop==num)
  2508.                             {
  2509.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2510.                                 else{printf("JAL %08X",tgt);}
  2511.                                 if(add>0&&tgt>=func-0x30000)
  2512.                                 {
  2513.                                     printf(" //%s",actor);
  2514.                                 }
  2515.                                 if(ext>0)
  2516.                                 {
  2517.                                     printf(" //External file %d",ext);
  2518.                                 }
  2519.                             }
  2520.                             ext=1;
  2521.                             if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A3))
  2522.                             {
  2523.                                 CPU[A3]=read32(RAM,func+(addr+1)*4)&0xffff;
  2524.                             }
  2525.                             for(loop=429;loop<1004;loop+=1)
  2526.                             {
  2527.                                 if(zenum_add[loop]==CPU[A3])
  2528.                                 {
  2529.                                     printf(" %s\n",zenum_sym[loop]);
  2530.                                     break;
  2531.                                 }
  2532.                             }
  2533.                             break;
  2534.                         case 0xD59DF4:
  2535.                             printf("%08X ",func+addr*4);
  2536.                             for(loop=0;loop<num;loop+=1)
  2537.                             {
  2538.                                 if(addr_db[loop]==tgt)
  2539.                                 {
  2540.                                     if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2541.                                     else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2542.                                     break;
  2543.                                 }
  2544.                             }
  2545.                             if(loop==num)
  2546.                             {
  2547.                                 if(op(inst)==J){printf("J %08X",tgt);}
  2548.                                 else{printf("JAL %08X",tgt);}
  2549.                                 if(add>0&&tgt>=func-0x30000)
  2550.                                 {
  2551.                                     printf(" //%s",actor);
  2552.                                 }
  2553.                                 if(ext>0)
  2554.                                 {
  2555.                                     printf(" //External file %d",ext);
  2556.                                 }
  2557.                             }
  2558.                             ext=1;
  2559.                             if((read32(RAM,func+addr*4+4)>>16)==0x2405)
  2560.                             {
  2561.                                 CPU[A1]=imm(read32(RAM,func+addr*4+4));
  2562.                             }
  2563.                             if(op(read32(RAM,func+addr*4+4))==ANDI)
  2564.                             {
  2565.                                 CPU[rt(read32(RAM,func+addr*4+4))]=CPU[rs(read32(RAM,func+addr*4+4))]&imm(read32(RAM,func+addr*4+4));
  2566.                             }
  2567.                             printf("\n");
  2568.                             message_set(RAM,CPU[A1]);
  2569.                             break;
  2570.                     }
  2571.                 }
  2572.                 if(ext!=1)
  2573.                 {
  2574.                     printf("%08X ",func+addr*4);
  2575.                     for(loop=0;loop<num;loop+=1)
  2576.                     {
  2577.                         if(addr_db[loop]==tgt)
  2578.                         {
  2579.                             if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
  2580.                             else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
  2581.                             break;
  2582.                         }
  2583.                     }
  2584.                     if(loop==num)
  2585.                     {
  2586.                         if(op(inst)==J){printf("J %08X",tgt);}
  2587.                         else{printf("JAL %08X",tgt);}
  2588.                         if(add>0&&tgt>=func-0x30000)
  2589.                         {
  2590.                             printf(" //%s",actor);
  2591.                         }
  2592.                         if(ext>0)
  2593.                         {
  2594.                             printf(" //External file %d",ext);
  2595.                         }
  2596.                     }
  2597.                     printf("\n");
  2598.                 }
  2599.                 ext=0;
  2600.                 break;
  2601.             case BEQ:
  2602.                 tgt=extend(imm(inst)<<2)+func+addr*4+4;
  2603.                 if(rs(inst)==R0 && rt(inst)==R0)
  2604.                 {
  2605.                     if(tgt<func+addr*4)
  2606.                     {
  2607.                         printf("break;   //%08X\n",tgt);
  2608.                     }
  2609.                     else
  2610.                     {
  2611.                         printf("(%s)\n",names[rs(inst)]);
  2612.                         printf("         case %s: //%08X\n",names[rt(inst)],tgt);
  2613.                     }
  2614.                 }
  2615.                 else
  2616.                 {
  2617.                     printf("(%s)\n",names[rs(inst)]);
  2618.                     printf("         case %s: //%08X\n",names[rt(inst)],tgt);
  2619.                 }
  2620.                 break;
  2621.             case ADDIU:
  2622.                 tgt=rt(inst);
  2623.                 if((func+addr*4)==addiu_jump[0]||(func+addr*4)==(addiu_jump[0]+4))
  2624.                 {
  2625.                     CPU[tgt]=addiu_jump[1];
  2626.                 }
  2627.                 CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
  2628.                 for(loop=0;loop<num;loop+=1)
  2629.                 {
  2630.                     if(addr_db[loop]==CPU[tgt])
  2631.                     {
  2632.                         if(CPU[tgt]>0xFFF&&tgt<T0)
  2633.                         {
  2634.                             if(CPU[tgt]<0x10000&&rs(inst)==R0){printf("%s = %s\n",names[tgt],symb_db[loop]);}
  2635.                             else
  2636.                             {
  2637.                                 if(CPU[tgt]>=0x80000000){printf("%s = %s\n",names[tgt],symb_db[loop]);}
  2638.                                 if(CPU[tgt]<0x80000000){printf("%s = 0x%X\n",names[tgt],CPU[tgt]);}
  2639.                             }
  2640.                             break;
  2641.                         }
  2642.                         else if(CPU[tgt]>0xFFF&&tgt>=T0)
  2643.                         {
  2644.                             if(CPU[tgt]<0x80000000)
  2645.                             {
  2646.                                 printf("%s = %s\n",names[tgt],symb_db[loop]);
  2647.                                 break;
  2648.                             }
  2649.                         }
  2650.                         else
  2651.                         {
  2652.                             if(tgt<T0)
  2653.                             {
  2654.                                 printf("%s = 0x%X\n",names[tgt],CPU[tgt]);
  2655.                                 break;
  2656.                             }
  2657.                             else
  2658.                             {
  2659.                                 if(CPU[tgt]<0x80000000)
  2660.                                 {
  2661.                                     printf("%08X\n",inst);
  2662.                                     break;
  2663.                                 }
  2664.                             }
  2665.                         }
  2666.                     }
  2667.                 }
  2668.                 if(loop==num)
  2669.                 {
  2670.                     if(CPU[tgt]>>24==0x80)
  2671.                     {
  2672.                         CPU[tgt]&=0x1FFFFFFF;
  2673.                         if(read32(RAM,0x3C)==0x242C343C&&CPU[tgt]>=0x510000)
  2674.                         {
  2675.                             if(read32(RAM,0x738C8)==0x25085690)
  2676.                             {
  2677.                                 CPU[tgt]-=0x3E70B0;
  2678.                             }
  2679.                             else
  2680.                             {
  2681.                                 CPU[tgt]-=pc;
  2682.                                 CPU[tgt]+=base[mode];
  2683.                             }
  2684.                         }
  2685.                         else if(read32(RAM,0x3C)==0x41464A00&&CPU[tgt]>=0x051A80)
  2686.                         {
  2687.                             CPU[tgt]+=0x623CA0;
  2688.                         }
  2689.                         else if(read32(RAM,0x3C)==0x534D4A00&&CPU[tgt]>=0x378800)
  2690.                         {
  2691.                             CPU[tgt]-=0x2845F0;
  2692.                         }
  2693.                         else if(read32(RAM,0x3C)==0x5A4C450F&&CPU[tgt]>=0x01CE60)
  2694.                         {
  2695.                             if(add>0&&CPU[tgt]>=0x800000)
  2696.                             {
  2697.                                 CPU[tgt]+=add;
  2698.                             }
  2699.                             else
  2700.                             {
  2701.                                 CPU[tgt]+=0xA771A0;
  2702.                             }
  2703.                         }
  2704.                         else if(read32(RAM,0x3C)==0x5A4C4A00&&CPU[tgt]>=0x0110A0)
  2705.                         {
  2706.                             CPU[tgt]+=0xA75F60;
  2707.                         }
  2708.                         else if(read32(RAM,0x3C)==0x5A535001&&CPU[tgt]>=0x0B6AC0)
  2709.                         {
  2710.                             if(add>0&&CPU[tgt]>=0x800000)
  2711.                             {
  2712.                                 CPU[tgt]+=add;
  2713.                             }
  2714.                             else
  2715.                             {
  2716.                                 CPU[tgt]+=0xBDE540;
  2717.                             }
  2718.                         }
  2719.                         else
  2720.                         {
  2721.                             if(CPU[tgt]>=pc&&CPU[tgt]<=end-4)
  2722.                             {
  2723.                                 CPU[tgt]-=pc;
  2724.                                 CPU[tgt]+=base[mode];
  2725.                             }
  2726.                             else
  2727.                             {
  2728.                                 goto label;
  2729.                             }
  2730.                         }
  2731.                         for(sum=0;sum<4;sum+=1)
  2732.                         {
  2733.                             if(RAM[CPU[tgt]+sum]<0x0A||RAM[CPU[tgt]+sum]>0x7E)
  2734.                             {
  2735.                                 break;
  2736.                             }
  2737.                         }
  2738.                         if(sum==4)
  2739.                         {
  2740.                             printf("%s = \"",names[tgt]);
  2741.                             while(sum!=0)
  2742.                             {
  2743.                                 sum=RAM[CPU[tgt]+ext];
  2744.                                 ext+=1;
  2745.                                 if(sum==0){break;}
  2746.                                 printf("%c",sum);
  2747.                             }
  2748.                             printf("\"\n");
  2749.                         }
  2750.                         if(read32(RAM,0x3C)==0x242C343C&&CPU[tgt]>=0x128F50)
  2751.                         {
  2752.                             if(read32(RAM,0x738C8)==0x25085690)
  2753.                             {
  2754.                                 CPU[tgt]+=0x3E70B0;
  2755.                             }
  2756.                             else
  2757.                             {
  2758.                                 CPU[tgt]-=base[mode];
  2759.                                 CPU[tgt]+=pc;
  2760.                             }
  2761.                         }
  2762.                         else if(read32(RAM,0x3C)==0x41464A00&&CPU[tgt]>=0x675720)
  2763.                         {
  2764.                             CPU[tgt]-=0x623CA0;
  2765.                         }
  2766.                         else if(read32(RAM,0x3C)==0x534D4A00&&CPU[tgt]>=0xF4210)
  2767.                         {
  2768.                             CPU[tgt]+=0x2845F0;
  2769.                         }
  2770.                         else if(read32(RAM,0x3C)==0x5A4C450F&&CPU[tgt]>=0xA94000)
  2771.                         {
  2772.                             if(CPU[tgt]>=ovl_b&&CPU[tgt]<ovl_e)
  2773.                             {
  2774.                                 CPU[tgt]-=add;
  2775.                             }
  2776.                             else
  2777.                             {
  2778.                                 CPU[tgt]-=0xA771A0;
  2779.                             }
  2780.                         }
  2781.                         else if(read32(RAM,0x3C)==0x5A4C4A00&&CPU[tgt]>=0xA87000)
  2782.                         {
  2783.                             CPU[tgt]-=0xA75F60;
  2784.                         }
  2785.                         else if(read32(RAM,0x3C)==0x5A535001&&CPU[tgt]>=0xC95000)
  2786.                         {
  2787.                             if(CPU[tgt]>=ovl_b&&CPU[tgt]<ovl_e)
  2788.                             {
  2789.                                 CPU[tgt]-=add;
  2790.                             }
  2791.                             else
  2792.                             {
  2793.                                 CPU[tgt]-=0xBDE540;
  2794.                             }
  2795.                         }
  2796.                         else
  2797.                         {
  2798.                             CPU[tgt]-=base[mode];
  2799.                             CPU[tgt]+=pc;
  2800.                         }
  2801.                         label:
  2802.                         CPU[tgt]|=0x80000000;
  2803.                     }
  2804.                     if(ext==0)
  2805.                     {
  2806.                         if(tgt<T0)
  2807.                         {
  2808.                             if((CPU[tgt]&0xffffff)>=(ovl_b-add)&&(CPU[tgt]&0xffffff)<(ovl_e-add))
  2809.                             {
  2810.                                 CPU[tgt]&=0xffffff;
  2811.                                 for(loop=0;loop<num;loop+=1)
  2812.                                 {
  2813.                                     if(addr_db[loop]==CPU[tgt]+add)
  2814.                                     {
  2815.                                         printf("%s = %s\n",names[tgt],symb_db[loop]);
  2816.                                         break;
  2817.                                     }
  2818.                                 }
  2819.                                 if(loop==num){CPU[tgt]|=0x80000000;printf("%s = 0x%X\n",names[tgt],CPU[tgt]);}
  2820.                             }
  2821.                             else{printf("%s = 0x%X\n",names[tgt],CPU[tgt]);}
  2822.                         }
  2823.                         else
  2824.                         {
  2825.                             for(loop=0;loop<num;loop+=1)
  2826.                             {
  2827.                                 if(add==0){break;}
  2828.                                 if(addr_db[loop]==(CPU[tgt]&0x1FFFFFFF)+add)
  2829.                                 {
  2830.                                     CPU[tgt]=loop; //new
  2831.                                     for(ext=addr+1;ext<(func_end/4);ext+=1)
  2832.                                     {
  2833.                                         if(op(read32(RAM,func+ext*4))>=40&&rt(read32(RAM,func+ext*4))==tgt)
  2834.                                         {
  2835.                                             if(rs(read32(RAM,func+ext*4))==SP)
  2836.                                             {
  2837.                                                 printf("%s = %s\n",names[tgt],symb_db[loop]);
  2838.                                             }
  2839.                                             else
  2840.                                             {
  2841.                                                 printf("%08X\n",inst);
  2842.                                             }
  2843.                                             break;
  2844.                                         }
  2845.                                     }
  2846.                                     break;
  2847.                                 }
  2848.                             }
  2849.                             if(loop==num||loop==0||ext==(func_end/4)){printf("%08X\n",inst);}
  2850.                             ext=0;
  2851.                         }
  2852.                     }
  2853.                 }
  2854.                 if(rs(inst)==R0&&rt(inst)==A0)
  2855.                 {
  2856.                 for(loop=addr+1;loop<(func_end/4);loop+=1)
  2857.                 {
  2858.                     if(rs(inst)==R0&&rt(inst)==A0)
  2859.                     {
  2860.                     if(read32(RAM,func+loop*4)==0x00801025)
  2861.                     {
  2862.                         message_set(RAM,CPU[A0]);
  2863.                     }
  2864.                     }
  2865.                     else{break;}
  2866.                 }
  2867.                 }
  2868.                 if((func+addr*4)==addiu_jump[0]||(func+addr*4)==(addiu_jump[0]+4))
  2869.                 {
  2870.                     addiu_jump[0]=4;
  2871.                 }
  2872.                 break;
  2873.             case ANDI:
  2874.                 tgt=rt(inst);
  2875.                 CPU[tgt]=CPU[rs(inst)]&imm(inst);
  2876.                 printf("%s = 0x%x\n",names[tgt],CPU[tgt]);
  2877.                 break;
  2878.             case ORI:
  2879.                 tgt=rt(inst);
  2880.                 CPU[tgt]=CPU[rs(inst)]|imm(inst);
  2881.                 for(loop=0;loop<num;loop+=1)
  2882.                 {
  2883.                     if(addr_db[loop]==CPU[tgt]&&CPU[tgt]>0xFFF)
  2884.                     {
  2885.                         printf("%s = %s\n",names[tgt],symb_db[loop]);
  2886.                         break;
  2887.                     }
  2888.                 }
  2889.                 if(loop==num)
  2890.                 {
  2891.                     printf("%08X\n",inst);
  2892.                 }
  2893.                 break;
  2894.             case LUI:
  2895.                 if(LUIWATCH[rt(inst)]==1){LUIWATCH[rt(inst)]=0;}
  2896.                 tgt=imm(inst);
  2897.                 CPU[rt(inst)]=tgt<<16;
  2898.                 for(loop=0;loop<num;loop+=1)
  2899.                 {
  2900.                     if(addr_db[loop]==tgt>>8)
  2901.                     {
  2902.                         for(tgt=addr+1;tgt<(func_end/4);tgt+=1)
  2903.                         {
  2904.                             if(op(read32(RAM,func+tgt*4))==SW&&rt(read32(RAM,func+tgt*4))==rt(inst)&&imm(read32(RAM,func+tgt*4))==0)
  2905.                             {
  2906.                                 if(op(read32(RAM,func+tgt*4+8))==SW)
  2907.                                 {
  2908.                                     if(rt(read32(RAM,func+tgt*4+8))!=rt(inst))
  2909.                                     {
  2910.                                         LUIWATCH[rt(inst)]=1;
  2911.                                     }
  2912.                                     else if(rt(read32(RAM,func+tgt*4+8))==rt(inst))
  2913.                                     {
  2914.                                         if((imm(read32(RAM,func+tgt*4+8))&0xF)==0)
  2915.                                         {
  2916.                                             LUIWATCH[rt(inst)]=1;
  2917.                                         }
  2918.                                     }
  2919.                                 }
  2920.                                 else if(op(read32(RAM,func+tgt*4+8))!=SW)
  2921.                                 {
  2922.                                     LUIWATCH[rt(inst)]=1;
  2923.                                 }
  2924.                                 break;
  2925.                             }
  2926.                         }
  2927.                         break;
  2928.                     }
  2929.                 }
  2930.                 if(op(read32(RAM,func+(addr+1)*4))>=BEQ&&op(read32(RAM,func+(addr+1)*4))<ADDI)
  2931.                 {
  2932.                     addiu_jump[0]=extend(imm(read32(RAM,func+(addr+1)*4))<<2)+func+addr*4+8;
  2933.                     addiu_jump[1]=CPU[rt(inst)];
  2934.                 }
  2935.                 break;
  2936.             case BNEL:
  2937.                 tgt=func+addr*4+4;
  2938.                 RAM[tgt]=0;
  2939.                 RAM[tgt+1]=0;
  2940.                 RAM[tgt+2]=0;
  2941.                 RAM[tgt+3]=0;
  2942.                 printf("%08X\n",inst);
  2943.                 break;
  2944.             case LB:
  2945.                 tgt=rt(inst);
  2946.                 CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
  2947.                 for(loop=0;loop<num;loop+=1)
  2948.                 {
  2949.                     if(addr_db[loop]==CPU[tgt]&&CPU[tgt]>0xFFF)
  2950.                     {
  2951.                         printf("%s = %s\n",names[tgt],symb_db[loop]);
  2952.                         break;
  2953.                     }
  2954.                 }
  2955.                 if(loop==num)
  2956.                 {
  2957.                     printf("%08X\n",inst);
  2958.                 }
  2959.                 break;
  2960.             case LW:
  2961.                 tgt=rt(inst);
  2962.                 CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
  2963.                 if(rs(inst)==SP)
  2964.                 {
  2965.                     printf("%s = sp%x\n",names[tgt],extend(imm(inst)));
  2966.                 }
  2967.                 else
  2968.                 {
  2969.                     for(loop=0;loop<num;loop+=1)
  2970.                     {
  2971.                         if(addr_db[loop]==CPU[tgt]&&CPU[tgt]>0xFFF)
  2972.                         {
  2973.                             printf("%s = %s\n",names[tgt],symb_db[loop]);
  2974.                             break;
  2975.                         }
  2976.                     }
  2977.                     if(loop==num)
  2978.                     {
  2979.                         printf("%08X\n",inst);
  2980.                     }
  2981.                 }
  2982.                 break;
  2983.             case LH:
  2984.             case LHU:
  2985.                 tgt=CPU[rs(inst)]+extend(imm(inst));
  2986.                 if(rs(inst)>=A0&&rs(inst)<T0&&tgt>=(regs|0x80000000)&&ovl_b>4)
  2987.                 {
  2988.                     if(func>=ovl_b&&func<ovl_e)
  2989.                     {
  2990.                     tgt&=0x1fffffff;
  2991.                     tgt-=regs;
  2992.                     if(tgt<=0x3FFFE){CPU[rt(inst)]=(REG[tgt]<<8)|REG[tgt+1];}
  2993.                     for(loop=0;loop<num;loop+=1)
  2994.                     {
  2995.                         if(addr_db[loop]==((tgt+regs)|0x80000000))
  2996.                         {
  2997.                             printf("%s = %s",names[rt(inst)],symb_db[loop]);
  2998.                             break;
  2999.                         }
  3000.                     }
  3001.                     if(loop==num)
  3002.                     {
  3003.                         printf("%s = 0x%X",names[rt(inst)],((tgt+regs)|0x80000000));
  3004.                     }
  3005.                     }
  3006.                 }
  3007.                 if(add>0)
  3008.                 {
  3009.                     switch(imm(inst))
  3010.                     {
  3011.                         case 0x10E:
  3012.                         case 0x2C4:
  3013.                             if(read32(RAM,0x3C)==0x5A4C450F)
  3014.                             {
  3015.                                 if(rt(inst)!=A1){CPU[rt(inst)]=0x10E;}
  3016.                             }
  3017.                             if(read32(RAM,0x3C)==0x5A535001)
  3018.                             {
  3019.                                 if(rt(inst)!=A1){CPU[rt(inst)]=0x2C4;}
  3020.                             }
  3021.                     }
  3022.                 }
  3023.                 //if(add>0&&imm(inst)==0x10E)
  3024.                 //{
  3025.                 //    if(rt(inst)!=A1){CPU[rt(inst)]=0x10E;}
  3026.                 //}
  3027.                 if(op(inst)==LH||op(inst)==LHU)
  3028.                 {
  3029.                     if(tgt>=((ovl_b-add)|0x80000000)&&ovl_b>4)
  3030.                     {
  3031.                         if(func>=ovl_b&&func<ovl_e&&tgt<(regs|0x80000000))
  3032.                         {
  3033.                             tgt&=0x1fffffff;
  3034.                             tgt+=add;
  3035.                             if(tgt<(end-1))
  3036.                             {
  3037.                                 CPU[rt(inst)]=((RAM[tgt]<<8)|RAM[tgt+1]);
  3038.                                 if(op(inst)==LH)
  3039.                                 {
  3040.                                     CPU[rt(inst)]=extend((unsigned short)(CPU[rt(inst)]));
  3041.                                 }
  3042.                             }
  3043.                         }
  3044.                     }
  3045.                 }
  3046.                 printf("\n");
  3047.                 break;
  3048.             case SB:
  3049.             case SH:
  3050.             case SW:
  3051.                 tgt=CPU[rs(inst)]+extend(imm(inst));
  3052.                 if(LUIWATCH[rt(inst)]==1){goto gfx;}
  3053.                 for(loop=0;loop<num;loop+=1)
  3054.                 {
  3055.                     if(addr_db[loop]==tgt&&tgt>0xFFF)
  3056.                     {
  3057.                         printf("%s = %s",symb_db[loop],names[rt(inst)]);
  3058.                         break;
  3059.                     }
  3060.                 }
  3061.                 goto exit;
  3062.                 gfx:
  3063.                 for(loop=0;loop<num;loop+=1)
  3064.                 {
  3065.                     if(addr_db[loop]==CPU[rt(inst)]>>24&&imm(inst)==0)
  3066.                     {
  3067.                         printf("%08X //",inst);
  3068.                         decompile_gfx(addr_db,addr_db[loop],num,CPU[rt(inst)]&0xFFFFFF);
  3069.                         printf(" (%02X %06X)",addr_db[loop],CPU[rt(inst)]&0xFFFFFF);
  3070.                         break;
  3071.                     }
  3072.                 }
  3073.                 exit:
  3074.                 if(loop==num)
  3075.                 {
  3076.                 loop=0;
  3077.                 if(rt(inst)>=T0&&rt(inst)<K0&&add>0)
  3078.                 {
  3079.                     for(loop=0;loop<num;loop+=1)
  3080.                     {
  3081.                         if(addr_db[loop]==imm(inst)&&addr_db[loop]>0xFF)
  3082.                         {
  3083.                             if(CPU[rt(inst)]<num)
  3084.                             {
  3085.                                 printf("%s = %s",symb_db[loop],symb_db[CPU[rt(inst)]]);//names[rt(inst)]);
  3086.                             }
  3087.                             else
  3088.                             {
  3089.                                 printf("%s = 0x%X //add = %X",symb_db[loop],CPU[rt(inst)],add);
  3090.                             }
  3091.                             break;
  3092.                         }
  3093.                     }
  3094.                 }
  3095.                 if(loop==0||loop==num){printf("%08X",inst);}
  3096.                 }
  3097.                 printf("\n");
  3098.                 if(imm(inst)==0x10E||imm(inst)==0x2C4){CPU[A1]=CPU[rt(inst)];}
  3099.                 if(imm(inst)==0x116&&op(inst)==SH&&rt(inst)!=V0)
  3100.                 {
  3101.                     message_set(RAM,CPU[rt(inst)]);
  3102.                 }
  3103.                 break;
  3104.             default:
  3105.                 if(inst!=0)
  3106.                 {
  3107.                     printf("%08X\n",inst);
  3108.                 }
  3109.                 break;
  3110.         }
  3111.         if(op(read32(RAM,func+addr*4+4))==JAL)
  3112.         {
  3113.             printf("\n");
  3114.         }
  3115.         if(op(read32(RAM,func+addr*4-4))==JAL)
  3116.         {
  3117.             printf("\n\n");
  3118.         }
  3119.         if(((inst>>16)&0xFFF)==0x441)
  3120.         {
  3121.             if(CPU[rs(inst)]==0x10E)
  3122.             {
  3123.                 message_set(RAM,CPU[AT]);
  3124.             }
  3125.         }
  3126.     }
  3127.     choose:
  3128.     func_end=0;
  3129.     if(ovl_funcs[ovl_tracker]==0)
  3130.     {
  3131.     system("pause");
  3132.     printf("Go again? (y/n) ");
  3133.     scanf("%s",choice);
  3134.     if(choice[0]==0x79){goto again;}
  3135.     }
  3136.     else
  3137.     {
  3138.     goto again;
  3139.     }
  3140.     free(RAM);
  3141.     free(REG);
  3142.     return 0;
  3143. }
  3144.  
RAW Paste Data