load_symbols.c

#define sign(imm)    (unsigned short)(imm&0x8000)
#define op(inst)     (unsigned char)(inst>>26)
#define target(inst) (unsigned int)((inst&0x03ffffff)<<2)
#define imm(inst)    (unsigned int)(inst&0xffff)
#define funct(inst)  (unsigned char)(inst&0x3f)
#define rs(inst)     (unsigned char)((inst&0x03e00000)>>21)
#define rt(inst)     (unsigned char)((inst&0x001f0000)>>16)
#define rd(inst)     (unsigned char)((inst&0xf800)>>11)
#define sa(inst)     (unsigned char)((inst&0x07c0)>>6)

#define R0 0
#define AT 1
#define V0 2
#define V1 3
#define A0 4
#define A1 5
#define A2 6
#define A3 7
#define T0 8
#define T1 9
#define T2 10
#define T3 11
#define T4 12
#define T5 13
#define T6 14
#define T7 15
#define S0 16
#define S1 17
#define S2 18
#define S3 19
#define S4 20
#define S5 21
#define S6 22
#define S7 23
#define T8 24
#define T9 25
#define K0 26
#define K1 27
#define GP 28
#define SP 29
#define FP 30
#define RA 31

#define SPECIAL 0
#define REGIMM  1
#define J       2
#define JAL     3
#define BEQ     4
#define BNE     5
#define BLEZ    6
#define BGTZ    7
#define ADDI    8
#define ADDIU   9
#define SLTI    10
#define SLTIU   11
#define ANDI    12
#define ORI     13
#define XORI    14
#define LUI     15
#define COP0    16
#define COP1    17
#define COP2    18
#define BEQL    20
#define BNEL    21
#define BLEZL   22
#define BGTZL   23
#define DADDI   24
#define DADDIU  25
#define LDL     26
#define LDR     27
#define LB      32
#define LH      33
#define LWL     34
#define LW      35
#define LBU     36
#define LHU     37
#define LWR     38
#define LWU     39
#define SB      40
#define SH      41
#define SWL     42
#define SW      43
#define SDL     44
#define SDR     45
#define SWR     46
#define CACHE   47
#define LL      48
#define LWC1    49
#define LWC2    50
#define LLD     52
#define LDC1    53
#define LDC2    54
#define LD      55
#define SC      56
#define SWC1    57
#define SWC2    58
#define SCD     60
#define SDC1    61
#define SDC2    62
#define SD      63

#define SLL     0
#define SRL     2
#define SRA     3
#define SLLV    4
#define SRLV    6
#define SRAV    7
#define JR      8
#define JALR    9
#define SYSCALL 12
/*#define BREAK 13*/
#define SYNC    15
#define MFHI    16
#define MTHI    17
#define MFLO    18
#define MTLO    19
#define DSLLV   20
#define DSRLV   22
#define DSRAV   23
#define MULT    24
#define MULTU   25
#define DIV     26
#define DIVU    27
#define DMULT   28
#define DMULTU  29
#define DDIV    30
#define DDIVU   31
#define ADD     32
#define ADDU    33
#define SUB     34
#define SUBU    35
#define AND     36
#define OR      37
#define XOR     38
#define NOR     39
#define SLT     42
#define SLTU    43
#define DADD    44
#define DADDU   45
#define DSUB    46
#define DSUBU   47
#define TGE     48
#define TGEU    49
#define TLT     50
#define TLTU    51
#define TEQ     52
#define TNE     54
#define DSLL    56
#define DSRL    58
#define DSRA    59
#define DSLL32  60
#define DSRL32  62
#define DSRA32  63
#define CART 0
#include <stdio.h>
#define DISK 1
unsigned int addiu_jump[2]={4};
int ovl_b=4,ovl_e=8,regs;
char mapped=0;
unsigned int extend(unsigned short imm);
unsigned int extend(unsigned short imm)
{
     unsigned int extended;
     if(sign(imm)==0x8000)
     {
          extended=0xffff0000|imm;
     }
     else
     {
          extended=imm;
     }
     return extended;
}

unsigned int read32(unsigned char *RAM, int ptr);
unsigned int read32(unsigned char *RAM, int ptr)
{
    return (unsigned int)((RAM[ptr]<<24)|(RAM[ptr+1]<<16)|(RAM[ptr+2]<<8)|RAM[ptr+3]);
}

#define F3D_GBI     0
#define F3DEX_GBI   1
#define S2DEX_GBI   2
#define F3DEX_GBI_2 3

void decompile_gfx(int map[8192], unsigned char gbi, int num_symb, int cmd_hi);
void decompile_gfx(int map[8192], unsigned char gbi, int num_symb, int cmd_hi)
{
    int x;
    char MV[4]={16, 16, 0, 0}, MW[4]={0, 0, 0, 16}, ucode=F3D_GBI;
    for(x=0;x<num_symb;x+=1) //loop to detect which microcode the game uses
    {
        if(map[x]==0x0C){ucode=4;break;} //ZSort
        if(map[x]==0xAF){ucode=F3DEX_GBI;break;}
        if(map[x]==0xC1)
        {
            if(gbi==0x01){ucode=F3DEX_GBI;break;}
            if(gbi>=0x02&&gbi<0x06){ucode=S2DEX_GBI;break;}
            if(gbi==0x06){ucode=F3DEX_GBI;break;}
            if(gbi==0xAF){ucode=F3DEX_GBI;break;}
            if(gbi==0xB0){ucode=S2DEX_GBI;break;}
            if(gbi==0xB1)
            {
                if(cmd_hi>0x40){ucode=F3DEX_GBI;break;}
                if(cmd_hi<=0x40){ucode=S2DEX_GBI;break;}
            }
            if(gbi==0xB2){ucode=S2DEX_GBI;break;}
            if(gbi>=0xB5&&gbi<0xC1){ucode=F3DEX_GBI;break;}
            if(gbi>=0xC1){ucode=S2DEX_GBI;break;}
        }
        if(map[x]==0xE3){ucode=F3DEX_GBI_2;break;}
    }
    switch(gbi) //first try the hardwired commands
    {
        case 0xE4:
            printf("gSPTextureRectangle");
            break;
        case 0xE5:
            printf("gSPTextureRectangleFlip");
            break;
        case 0xE6:
            printf("gDPLoadSync");
            break;
        case 0xE7:
            printf("gDPPipeSync");
            break;
        case 0xE8:
            printf("gDPTileSync");
            break;
        case 0xE9:
            printf("gDPFullSync");
            break;
        case 0xEA:
            printf("gDPSetKeyGB");
            break;
        case 0xEB:
            printf("gDPSetKeyR");
            break;
        case 0xEC:
            printf("gDPSetConvert");
            break;
        case 0xED:
            printf("gDPSetScissor");
            break;
        case 0xEE:
            printf("gDPSetPrimDepth");
            break;
        case 0xEF:
            printf("gDPSetOtherMode");
            break;
        case 0xF0:
            printf("gDPLoadTLUT");
            break;
        case 0xF2:
            printf("gDPSetTileSize");
            break;
        case 0xF3:
            printf("gDPLoadBlock");
            break;
        case 0xF4:
            printf("gDPLoadTile");
            break;
        case 0xF5:
            printf("gDPSetTile");
            break;
        case 0xF6:
            printf("gDPFillRectangle");
            break;
        case 0xF7:
            printf("gDPSetFillColor");
            break;
        case 0xF8:
            printf("gDPSetFogColor");
            break;
        case 0xF9:
            printf("gDPSetBlendColor");
            break;
        case 0xFA:
            printf("gDPSetPrimColor");
            break;
        case 0xFB:
            printf("gDPSetEnvColor");
            break;
        case 0xFC:
            printf("gDPSetCombine");
            break;
        case 0xFD:
            printf("gDPSetTextureImage");
            break;
        case 0xFE:
            printf("gDPSetDepthImage");
            break;
        case 0xFF:
            printf("gDPSetColorImage");
            break;
    }
    if(ucode==F3D_GBI||ucode==F3DEX_GBI)
    {
        if(gbi==0x01){printf("gSPMatrix");return;}
        if(gbi==0x03){goto MOVEMEM;}
        if(gbi==0x04){printf("gSPVertex");return;}
        if(gbi==0x06)
        {
            switch(cmd_hi>>16&0xff)
            {
                case 0:
                    printf("gSPDisplayList");
                    break;
                case 1:
                    printf("gSPBranchList");
                    break;
            }
            return;
        }
        if(gbi==0xAF){printf("gSPLoadUcodeEx");return;}
        if(gbi==0xB0){printf("gSPBranchLessZ");return;}
        if(gbi==0xB1){printf("gSP2Triangles");return;}
        if(gbi==0xB2){printf("gSPModifyVertex");return;}
        if(gbi==0xB5){printf("gSP1Quadrangle");return;}
        if(gbi==0xB6){printf("gSPClearGeometryMode");return;}
        if(gbi==0xB7){printf("gSPSetGeometryMode");return;}
        if(gbi==0xB8){printf("gSPEndDisplayList");return;}
        if(gbi==0xB9)
        {
            x=cmd_hi>>8;
            goto SETOTHERMODE_L;
        }
        if(gbi==0xBA)
        {
            x=cmd_hi>>8;
            goto SETOTHERMODE_H;
        }
        if(gbi==0xBB){printf("gSPTexture");return;}
        if(gbi==0xBC){goto MOVEWORD;}
        if(gbi==0xBD){printf("gSPPopMatrix");return;}
        if(gbi==0xBE){printf("gSPCullDisplayList");return;}
        if(gbi==0xBF){printf("gSP1Triangle");return;}
    }
    else if(ucode==S2DEX_GBI)
    {
        if(gbi==0x01){printf("gSPBgRect1Cyc");}
        if(gbi==0x02){printf("gSPBgRectCopy");}
        if(gbi==0x03){printf("gSPObjRectangle");}
        if(gbi==0x04){printf("gSPObjSprite");}
        if(gbi==0x05)
        {
            switch(cmd_hi&0xffff)
            {
                case 0:
                    printf("gSPObjMatrix");
                    break;
                case 2:
                    printf("gSPObjSubMatrix");
                    break;
                case 8:
                    printf("gSPViewport");
                    break;
            }
        }
        if(gbi==0xB0)
        {
            switch(cmd_hi>>16&0xff)
            {
                case 0:
                    printf("gSPDisplayList");
                    break;
                case 1:
                    printf("gSPBranchList");
                    break;
            }
        }
        if(gbi==0xB1){printf("gSPObjRenderMode");}
        if(gbi==0xB2){printf("gSPObjRectangleR");}
        if(gbi==0xC1){printf("gSPObjLoadTxtr");}
        if(gbi==0xC2){printf("gSPObjLoadTxSprite");}
        if(gbi==0xC3){printf("gSPObjLoadTxRect");}
        if(gbi==0xC4){printf("gSPObjLoadTxRectR");}
        return;
    }
    else if(ucode==F3DEX_GBI_2)
    {
        if(gbi==0x01){printf("gSPVertex");return;}
        if(gbi==0x02){printf("gSPModifyVertex");return;}
        if(gbi==0x03){printf("gSPCullDisplayList");return;}
        if(gbi==0x04){printf("gSPBranchLessZ");return;}
        if(gbi==0x05){printf("gSP1Triangle");return;}
        if(gbi==0x06){printf("gSP2Triangles");return;}
        if(gbi==0x07){printf("gSP1Quadrangle");return;}
        if(gbi==0xD7){printf("gSPTexture");return;}
        if(gbi==0xD8){printf("gSPPopMatrix");return;}
        if(gbi==0xD9){printf("gSPGeometryMode");return;}
        if(gbi==0xDA){printf("gSPMatrix");return;}
        if(gbi==0xDB){goto MOVEWORD;}
        if(gbi==0xDC){goto MOVEMEM;}
        if(gbi==0xDD){printf("gSPLoadUcodeEx");return;}
        if(gbi==0xDE)
        {
            switch(cmd_hi>>16&0xff)
            {
                case 0:
                    printf("gSPDisplayList");
                    break;
                case 1:
                    printf("gSPBranchList");
                    break;
            }
            return;
        }
        if(gbi==0xDF){printf("gSPEndDisplayList");return;}
        if(gbi==0xE2)
        {
            x=32-(cmd_hi>>8);
            cmd_hi&=0xFF;
            x-=cmd_hi+1;
            goto SETOTHERMODE_L;
        }
        if(gbi==0xE3)
        {
            x=32-(cmd_hi>>8);
            cmd_hi&=0xFF;
            x-=cmd_hi+1;
            goto SETOTHERMODE_H;
        }
    }
    else
    {
        if(gbi==0x04)
        {
            switch(cmd_hi&0xfff)
            {
                case 0:
                    printf("gSPZViewPort");
                    break;
                case 0x830:
                case 0x870:
                case 0x8b0:
                    if((cmd_hi>>23)&1==0)
                    {
                        printf("gSPZSetMtx");
                    }
                    else
                    {
                        printf("gSPZGetMtx");
                    }
                    break;
                default:
                    printf("Unknown Move");
                    break;
            }
        }
        if(gbi==0x08){printf("gSPZMtxTrnsp3x3");}
        if(gbi==0x0A){printf("gSPZMtxCat");}
        if(gbi==0x0C){printf("gSPZMultMPMtx");}
        if(gbi==0x0E){printf("gSPZRdpCmd");}
        if(gbi==0x10){printf("gSPZSendMessage");}
        if(gbi==0x12){printf("gSPZWaitSignal");}
        if(gbi==0x14)
        {
            if((cmd_hi>>12)&0xfff>0)
            {
                printf("gSPZLightMaterial");
            }
            else
            {
                printf("gSPZLight");
            }
        }
        if(gbi==0xE2){printf("Other Mode (L)");}
        if(gbi==0xE3){printf("Other Mode (H)");}
        return;
    }
    MOVEMEM:
    switch(cmd_hi>>MV[ucode]&0xff)
    {
        case 0x08:
        case 0x80:
            printf("gSPViewport");
            break;
        case 0x0A:
        case 0x86:
        case 0x88:
        case 0x8A:
        case 0x8C:
        case 0x8E:
        case 0x90:
        case 0x92:
        case 0x94:
            printf("gSPLight");
            break;
        case 0x0E:
        case 0x9E:
            printf("gSPForceMatrix");
            break;
    }
    return;
    SETOTHERMODE_L:
    switch(x)
    {
        case 0:
            printf("gDPSetAlphaCompare");
            break;
        case 2:
            printf("gDPSetDepthSource");
            break;
        case 3:
            printf("gDPSetRenderMode");
            break;
    }
    return;
    SETOTHERMODE_H:
    switch(x)
    {
        case 4:
            printf("gDPSetAlphaDither");
            break;
        case 6:
            printf("gDPSetColorDither");
            break;
        case 8:
            printf("gDPSetCombineKey");
            break;
        case 9:
            printf("gDPSetTextureConvert");
            break;
        case 12:
            printf("gDPSetTextureFilter");
            break;
        case 14:
            printf("gDPSetTextureLUT");
            break;
        case 16:
            printf("gDPSetTextureLOD");
            break;
        case 17:
            printf("gDPSetTextureDetail");
            break;
        case 19:
            printf("gDPSetTexturePersp");
            break;
        case 20:
            printf("gDPSetCycleType");
            break;
        case 23:
            printf("gDPPipelineMode");
            break;
    }
    return;
    MOVEWORD:
    switch(cmd_hi>>MW[ucode]&0xff)
    {
        case 0x0:
            printf("gSPInsertMatrix");
            break;
        case 0x2:
            printf("gSPNumLights");
            break;
        case 0x4:
            printf("gSPClipRatio");
            break;
        case 0x6:
            printf("gSPSegment");
            break;
        case 0x8:
            printf("gSPFogFactor");
            break;
        case 0xA:
            printf("gSPLightColor");
            break;
        case 0xC:
            printf("gSPModifyVertex");
            break;
        case 0xE:
            printf("gSPPerspNormalize");
            break;
    }
}

void message_set(unsigned char *RAM, unsigned int id)
{
    int found=0;
    int seek=0;
    int temp=0;
    if(read32(RAM,0x3C)!=0x444C4500&&read32(RAM,0x3C)!=0x5A4C450F){return;}
    if(read32(RAM,0x3C)==0x444C4500)
    {
    while(found!=id)
    {
        found=(int)((RAM[0xC5D2D8+seek]<<8)|RAM[0xC5D2D9+seek]);
        seek+=8;
        if(seek==0x8F58){break;}
    }
    if(seek==0x8F58){return;}
    found=read32(RAM,0xC5D2D4+seek)&0xffffff;
    found+=0xAD200B;
    seek=1;
    while(seek!=0xBF)
    {
        seek=RAM[found+temp];
        switch(seek)
        {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
            case 8:
            case 0xB:
            case 0xC:
            case 0xD:
            case 0x13:
            case 0x15:
            case 0x16:
            case 0x17:
            case 0x18:
            case 0x19:
            case 0x1A:
            case 0xC2:
            case 0xC3:
            case 0xC4:
            case 0xC8:
            case 0xCC:
            case 0xCD:
            case 0xCE:
            case 0xCF:
            case 0xD0:
            case 0xD1:
            case 0xD2:
            case 0xD4:
            case 0xD5:
            case 0xD7:
            case 0xD8:
            case 0xD9:
            case 0xDA:
            case 0xDB:
            case 0xDC:
            case 0xDD:
            case 0xDE:
            case 0xDF:
            case 0xE0:
            case 0xE1:
            case 0xE2:
            case 0xE3:
            case 0xE4:
            case 0xE5:
            case 0xE6:
            case 0xE7:
            case 0xE8:
            case 0xF6:
            case 0xF9:
            case 0xFA:
            case 0xFB:
            case 0xFC:
                temp+=1;
                break;
            case 0x10:
            case 0x12:
                temp+=1;
                printf("\n==\n");
                break;
            case 0x11:
                temp+=1;
                printf("\n");
                break;
            case 0x1B:
            case 0x1C:
            case 0x1D:
            case 0x1F:
                temp+=3;
                break;
            case 0x1E:
                temp+=3;
                break;
            case 0xBF:
                temp+=1;
                printf("\n\n\n");
                break;
            default:
                temp+=1;
                printf("%c",seek);
                break;
        }
    }
    system("pause");
    return;
    }
    while(found!=id)
    {
        found=(int)((RAM[0xBC24C0+seek]<<8)|RAM[0xBC24C1+seek]);
        seek+=8;
        if(seek==0x4210){break;}
    }
    if(seek==0x4210){return;}
    found=read32(RAM,0xBC24BC+seek)&0xffffff;
    found+=0x8C6000;
    seek=1;
    while(seek!=2)
    {
        seek=RAM[found+temp];
        switch(seek)
        {
            case 3:
            case 8:
            case 9:
            case 0xA:
            case 0xB:
            case 0xD:
            case 0xF:
            case 0x10:
            case 0x11:
            case 0x16:
            case 0x17:
            case 0x18:
            case 0x19:
            case 0x1A:
            case 0x1B:
            case 0x1C:
            case 0x1D:
            case 0x1F:
                temp+=1;
                break;
            case 1:
                temp+=1;
                printf("\n");
                break;
            case 2:
                temp+=1;
                printf("\n\n\n");
                break;
            case 4:
                temp+=1;
                printf("\n==\n");
                break;
            case 7:
                temp+=3;
                break;
            case 0x12:
                temp+=3;
                break;
            case 0x15:
                temp+=4;
                break;
            case 5:
            case 6:
            case 0xC:
            case 0xE:
            case 0x13:
            case 0x14:
            case 0x1E:
                temp+=2;
                break;
            default:
                temp+=1;
                printf("%c",seek);
                break;
        }
    }
    system("pause");
}

void map(unsigned char *RAM, unsigned char *REG, unsigned char *DEMO, int add, int start, int offset)
{
    unsigned int CPU[32], inst, tgt;
    int loop, newvar, newvar2;
    int found=0, there;
    CPU[0]=0;
    newvar=offset-read32(RAM,offset-4);
    int len=read32(RAM,newvar);
    newvar2=len;
    newvar2+=read32(RAM,newvar+4);
    newvar2+=read32(RAM,newvar+8);
    regs=start-add+newvar2;
    for(loop=0;loop<len;loop+=4)
    {
        inst=read32(RAM,start+loop);
        switch(op(inst))
        {
            case ADDIU:
                tgt=rt(inst);
                CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
                break;
            case LUI:
                tgt=imm(inst);
                CPU[rt(inst)]=tgt<<16;
                break;
            case SB:
                tgt=CPU[rs(inst)]+extend(imm(inst));
                if(rs(inst)==AT&&tgt>=(regs|0x80000000))
                {
                    tgt&=0x1fffffff;
                    tgt-=regs;
                    REG[tgt]=CPU[rt(inst)];
                }
                break;
            case SH:
                tgt=CPU[rs(inst)]+extend(imm(inst));
                if(rs(inst)==AT&&tgt>=(regs|0x80000000))
                {
                    tgt&=0x1fffffff;
                    tgt-=regs;
                    REG[tgt]=CPU[rt(inst)]>>8;
                    REG[tgt+1]=CPU[rt(inst)]&0xff;
                }
                break;
            case SW:
                tgt=CPU[rs(inst)]+extend(imm(inst));
                if(rs(inst)==AT&&tgt>=(regs|0x80000000))
                {
                    tgt&=0x1fffffff;
                    tgt-=regs;
                    REG[tgt]=CPU[rt(inst)]>>24;
                    REG[tgt+1]=(CPU[rt(inst)]>>16)&0xff;
                    REG[tgt+2]=(CPU[rt(inst)]>>8)&0xff;
                    REG[tgt+3]=CPU[rt(inst)]&0xff;
                }
                break;
        }
    }
    scan:
    if(RAM[0x3C]==0x5A&&RAM[0x3D]==0x53)
    {
        if(found!=1)
        {
            found=0;
            there=start+len;
        }
        while(RAM[there]!=0x80)
        {
            if(RAM[there]==0x0E)
            {
                if(RAM[there+3]==0x0C&&RAM[there+5]==0)
                {
                    found=there;
                    break;
                }
                if(RAM[there+3]==0x2D&&RAM[there+4]==0)
                {
                    found=there;
                    break;
                }
            }
            there+=1;
        }
        if(found==0)
        {
            while(RAM[there]==0x80)
            {
                there+=4;
            }
            found=1;
            goto scan;

        }
        if(found>1)
        {
            there=found;
            while(RAM[there]!=0x80) //PROCESS THE SCRIPT
            {
                switch(RAM[there])
                {
                    case 0x0E:
                    case 0x0F:
                    case 0x2C:
                        if((unsigned short)((RAM[there+1]<<8)|RAM[there+2])>0)
                        {
                            printf("================================\n0x%04x\n\n",(unsigned short)(RAM[there+1]<<8)|RAM[there+2]);
                            message_set(DEMO,(unsigned short)(RAM[there+1]<<8)|RAM[there+2]);
                            printf("\n");
                            there+=2;
                        }
                        break;
                    case 0x2D:
                        printf("\n\n");
                        there+=2;
                }
                there+=1;
            }
        }
    }
}

int ovl_adapt(unsigned char *RAM, unsigned char *REG, unsigned char *DEMO, int func, unsigned int magic)
{
    int loop, add;
    add=0;
    if(magic!=0x5A4C450F){goto ZS;}
    for(loop=0;loop<0x1FC;loop+=1)
    {
        if(loop>=0x1D7)
        {
            RAM[0xB897D4+0x1C*loop]=0;
            if(func>=read32(RAM,0xB897CC+0x1C*loop)&&func<read32(RAM,0xB897D0+0x1C*loop))
            {
                add=read32(RAM,0xB897CC+0x1C*loop)-read32(RAM,0xB897D4+0x1C*loop);
                break;
            }
        }
        else
        {
            RAM[0xB8D448+0x20*loop]=0;
            RAM[0xB8D458+0x20*loop]=0;
            if(func>=read32(RAM,0xB8D440+0x20*loop)&&func<read32(RAM,0xB8D444+0x20*loop))
            {
                add=read32(RAM,0xB8D440+0x20*loop)-read32(RAM,0xB8D448+0x20*loop);
                break;
            }
        }
    }
    if(mapped==1)
    {
        if(func<ovl_b||func>=ovl_e)
        {
            for(magic=0;magic<0x40000;magic+=1)
            {
                REG[magic]=0;
            }
            mapped=0;
        }
    }
    if(mapped==0)
    {
        if(loop>=0x1D7)
        {
            ovl_b=read32(RAM,0xB897CC+0x1C*loop);
            ovl_e=read32(RAM,0xB897D0+0x1C*loop);
        }
        else
        {
            if(loop<0x1FC)
            {
            ovl_b=read32(RAM,0xB8D440+0x20*loop);
            ovl_e=read32(RAM,0xB8D444+0x20*loop);
            }
        }
        if(loop<0x1FC)
        {
            map(RAM,REG,DEMO,add,ovl_b,ovl_e);
            mapped=1;
        }
    }
    return add;
    ZS:
    for(loop=0;loop<0x2B2;loop+=1)
    {
        RAM[0xC617C8+0x20*loop]=0;
        RAM[0xC617D8+0x20*loop]=0;
        if(func>=read32(RAM,0xC617C0+0x20*loop)&&func<read32(RAM,0xC617C4+0x20*loop))
        {
            add=read32(RAM,0xC617C0+0x20*loop)-read32(RAM,0xC617C8+0x20*loop);
            break;
        }
    }
    if(mapped==1)
    {
        if(func<ovl_b||func>=ovl_e)
        {
            for(magic=0;magic<0x40000;magic+=1)
            {
                REG[magic]=0;
            }
            mapped=0;
        }
    }
    if(mapped==0)
    {
        if(loop<0x2B2)
        {
        ovl_b=read32(RAM,0xC617C0+0x20*loop);
        ovl_e=read32(RAM,0xC617C4+0x20*loop);
        }
        if(loop<0x2B2)
        {
            map(RAM,REG,DEMO,add,ovl_b,ovl_e);
            mapped=1;
        }
    }
    return add;
}

char pointers[1532][64]={0};
unsigned short exit_list[31];
int scene_start;

void exits(unsigned char *RAM, int start_offset, char mode, short x_doord, short y_doord, short z_doord)
{
    int exit_table, pointer;
    int edge_where, poly_where, type_where, x;
    short highest=0, poly_load, poly_type, x_coord, y_coord, z_coord;
    int scene_depth=start_offset;
    while(RAM[scene_depth]!=0x14)
    {
        if(RAM[scene_depth]==3)
        {
            pointer=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
        }
        if(RAM[scene_depth]==0x13)
        {
            exit_table=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
        }
        scene_depth+=8;
    }
    if(mode<2)
    {
    edge_where=scene_start+(read32(RAM,pointer+16)&0xffffff);
    poly_load=(short)((RAM[pointer+20]<<8)|RAM[pointer+21]);
    poly_where=scene_start+(read32(RAM,pointer+24)&0xffffff);
    type_where=scene_start+(read32(RAM,pointer+28)&0xffffff);
    if(mode==0)
    {
    for(x=0;x<31;x+=1){exit_list[x]=0xFFFF;}
    for(x=0;x<(poly_load*16);x+=16)
    {
        poly_type=(short)((RAM[poly_where+x]<<8)|RAM[1+poly_where+x]);
        scene_depth=RAM[2+type_where+poly_type*8]&0x1f;
        if(scene_depth>highest)
        {
            highest=scene_depth;
        }
    }
    for(x=0;x<(highest*2);x+=2)
    {
        exit_list[(x/2)]=(short)((RAM[exit_table+x]<<8)|RAM[1+exit_table+x]);
    }
    }
    if(mode==1)
    {
    for(x=0;x<(poly_load*16);x+=16)
    {
        poly_type=(short)((RAM[poly_where+x]<<8)|RAM[1+poly_where+x]);
        scene_depth=RAM[2+type_where+poly_type*8]&0x1f;
        exit_table=(short)((RAM[2+poly_where+x]<<8)|RAM[3+poly_where+x]);
        exit_table&=0x1fff;
        x_coord=(short)((RAM[edge_where+exit_table*6]<<8)|RAM[1+edge_where+exit_table*6]);
        y_coord=(short)((RAM[2+edge_where+exit_table*6]<<8)|RAM[3+edge_where+exit_table*6]);
        z_coord=(short)((RAM[4+edge_where+exit_table*6]<<8)|RAM[5+edge_where+exit_table*6]);
        if(y_coord>=y_doord&&y_coord<(y_doord+16))
        {
            if(z_coord>=(z_doord-32)&&z_coord<(z_doord+32))
            {
            if(scene_depth>0&&exit_list[scene_depth-1]<0xFFFF)
            {
                if(read32(RAM,0x3C)==0x5A534A00)
                {
                RAM[0xC77F88+0xC*(exit_list[scene_depth-1]>>9)]=0;
                RAM[0xC77F8C+0xC*(exit_list[scene_depth-1]>>9)]=0;
                exit_table=0xAB7960+read32(RAM,0xC77F88+0xC*(exit_list[scene_depth-1]>>9));
                pointer=0xAB7960+read32(RAM,0xC77F8C+0xC*(exit_list[scene_depth-1]>>9));
                RAM[exit_table]=0;
                edge_where=0xAB7960+read32(RAM,exit_table);
                exit_table=RAM[edge_where];
                if(exit_table>127)
                {
                    exit_table=256-exit_table;
                }
                printf("->%04X %02X ",exit_list[scene_depth-1],exit_table);
                exit_table=1;
                edge_where=0;
                while(exit_table!=0)
                {
                    exit_table=RAM[pointer+edge_where];
                    edge_where+=1;
                    printf("%c",exit_table);
                }
                printf("(%02X)",scene_depth-1);
                }
                else
                {
                pointer=RAM[0xB9F360+exit_list[scene_depth-1]*4];
                exit_table=read32(RAM,0xBA0BB0+pointer*0x14);
                for(x_coord=0;x_coord<1532;x_coord+=1)
                {
                    if(read32(RAM,0x12F70+x_coord*16)==exit_table)
                    {
                        break;
                    }
                }
                printf("->%04X %02X %s %08X %02X",exit_list[scene_depth-1],pointer,pointers[x_coord],0xB9F360+exit_list[scene_depth-1]*4,scene_depth-1);
                }
                exit_list[scene_depth-1]=0xFFFF;
                break;
            }
            }
        }
    }
    }
    }
    if(mode==2)
    {
        for(x=0;x<31;x+=1)
        {
            if(exit_list[x]<0xFFFF)
            {
                if(read32(RAM,0x3C)==0x5A534A00)
                {
                RAM[0xC77F88+0xC*(exit_list[x]>>9)]=0;
                RAM[0xC77F8C+0xC*(exit_list[x]>>9)]=0;
                exit_table=0xAB7960+read32(RAM,0xC77F88+0xC*(exit_list[x]>>9));
                pointer=0xAB7960+read32(RAM,0xC77F8C+0xC*(exit_list[x]>>9));
                RAM[exit_table]=0;
                edge_where=0xAB7960+read32(RAM,exit_table);
                exit_table=RAM[edge_where];
                if(exit_table>127)
                {
                    exit_table=256-exit_table;
                }
                printf("%04X %02X ",exit_list[x],exit_table);
                exit_table=1;
                edge_where=0;
                while(exit_table!=0)
                {
                    exit_table=RAM[pointer+edge_where];
                    edge_where+=1;
                    printf("%c",exit_table);
                }
                printf("(%02X)\n",x);
                }
                else
                {
                pointer=RAM[0xB9F360+exit_list[x]*4];
                exit_table=read32(RAM,0xBA0BB0+pointer*0x14);
                for(x_coord=0;x_coord<1532;x_coord+=1)
                {
                    if(read32(RAM,0x12F70+x_coord*16)==exit_table)
                    {
                        break;
                    }
                }
                printf("%04X %02X %s %08X %02X\n",exit_list[x],pointer,pointers[x_coord],0xB9F360+exit_list[x]*4,x);
                }
            }
        }
    }
}

void doors(unsigned char *RAM, unsigned char *DEMO, int start_offset, int zenum_add[8192], char zenum_sym[8192][128])
{
    int scene_depth=start_offset;
    int offset, offset2, offset3, offset4, loop;
    unsigned short type;
    unsigned char doors;
    if(read32(RAM,0x3C)==0x5A534A00)
    {
        goto MM;
    }
    while(RAM[scene_depth]!=0x14)
    {
        if(RAM[scene_depth]==0xE)
        {
            doors=RAM[scene_depth+1];
            offset=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
            for(offset2=offset;offset2<(offset+doors*0x10);offset2+=0x10)
            {
                for(loop=0;loop<0x1AD;loop+=1)
                {
                    if((unsigned short)((RAM[4+offset2]<<8)|RAM[5+offset2])==zenum_add[loop])
                    {
                        printf("%08X %s",offset2,zenum_sym[loop]);
                        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]));
                        printf("\n");
                        switch(zenum_add[loop])
                        {
                            case 9:
                                type=(unsigned short)(((RAM[14+offset2]&3)<<1)|(RAM[15+offset2]>>7));
                                if(type>=4&&type<7)
                                {
                                    message_set(RAM,0x200+(RAM[15+offset2]&0x3f));
                                }
                        }
                        break;
                    }
                }
            }
            break;
        }
        scene_depth+=8;
    }
    return;
    MM:
    while(RAM[scene_depth]!=0x14)
    {
        if(RAM[scene_depth]==0xE)
        {
            doors=RAM[scene_depth+1];
            offset=scene_start+(read32(RAM,scene_depth+4)&0xffffff);
            for(offset2=offset;offset2<(offset+doors*0x10);offset2+=0x10)
            {
                for(loop=0x1AD;loop<0x3EC;loop+=1)
                {
                    if((unsigned short)((RAM[4+offset2]<<8)|RAM[5+offset2])==zenum_add[loop])
                    {
                        printf("%08X %s",offset2,zenum_sym[loop]);
                        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]));
                        printf("\n");
                        switch(zenum_add[loop])
                        {
                            case 5:
                                type=(unsigned short)(((RAM[14+offset2]&3)<<1)|(RAM[15+offset2]>>7));
                                if(type==5)
                                {
                                    offset3=0x49B570+(read32(RAM,0xD0327C+(RAM[15+offset2]&0x7F)*4)&0xffffff);
                                    offset4=0x49B570+(read32(RAM,0xD03280+(RAM[15+offset2]&0x7F)*4)&0xffffff);
                                    while(type!=9)
                                    {
                                        type=RAM[offset3];
                                        switch(type)
                                        {
                                            case 0xE:
                                            case 0xF:
                                            case 0x2C:
                                            case 0x2D:
                                                offset3+=2;
                                        }
                                        offset3+=1;
                                        if((RAM[15+offset2]&0x7F)<0x1F&&offset3>=offset4){break;}
                                    }
                                    if(type==9){message_set(DEMO,0x1800+RAM[offset3]);}
                                }
                        }
                        break;
                    }
                }
            }
            break;
        }
        scene_depth+=8;
    }
}

void scene(unsigned char *RAM, unsigned char *DEMO, int func, int zenum_add[8192], char zenum_sym[8192][128])
{
    char objects[0x283][39]={
    "Object_Bank_Non",
    "Object_Bank_Keep",
    "Object_Bank_F_Keep",
    "Object_Bank_D_Keep",
    "Object_Bank_Nb",
    "Object_Bank_Okuta",
    "Object_Bank_Crow",
    "Object_Bank_Ah",
    "Object_Bank_Dy_Obj",
    "Object_Bank_Wallmaster",
    "Object_Bank_Dodongo",
    "Object_Bank_Firefly",
    "Object_Bank_Box",
    "Object_Bank_Al",
    "Object_Bank_Bubble",
    "Object_Bank_Niw",
    "Object_Bank_Link_Boy",
    "Object_Bank_Link_Child",
    "Object_Bank_Tite",
    "Object_Bank_Tab",
    "Object_Bank_Peehat",
    "Object_Bank_And",
    "Object_Bank_Msmo",
    "Object_Bank_Dinofos",
    "Object_Bank_Drs",
    "Object_Bank_Zl1",
    "Object_Bank_An4",
    "__dummy__Object_Bank_Dodojr",
    "Object_Bank_Torch2",
    "Object_Bank_Famos",
    "__dummy__Object_Bank_Tp",
    "__dummy__Object_Bank_OAX",
    "Object_Bank_St",
    "__dummy__Object_Bank_Bw",
    "Object_Bank_Thiefbird",
    "__dummy__Object_Bank_Horse_Normal",
    "__dummy__Object_Bank_OBX",
    "__dummy__Object_Bank_O_Anime",
    "__dummy__Object_Bank_Horse_Ganon",
    "__dummy__Object_Bank_OA2",
    "__dummy__Object_Bank_Spot00_Objects",
    "__dummy__Object_Bank_Mb",
    "Object_Bank_Bombf",
    "__dummy__Object_Bank_Sk2",
    "__dummy__Object_Bank_OE1",
    "__dummy__Object_Bank_OE_Anime",
    "__dummy__Object_Bank_OE2",
    "__dummy__Object_Bank_Boss_Ganondrof",
    "Object_Bank_Am",
    "Object_Bank_Dekubaba",
    "__dummy__Object_Bank_OA3",
    "__dummy__Object_Bank_OA4",
    "__dummy__Object_Bank_OA5",
    "__dummy__Object_Bank_OA6",
    "__dummy__Object_Bank_OA7",
    "__dummy__Object_Bank_OA8",
    "__dummy__Object_Bank_OA9",
    "__dummy__Object_Bank_OB2",
    "__dummy__Object_Bank_OB3",
    "__dummy__Object_Bank_OB4",
    "__dummy__Object_Bank_Horse_Zelda",
    "__dummy__Object_Bank_Opening_Demo1",
    "Object_Bank_Warp1",
    "Object_Bank_B_Heart",
    "Object_Bank_Dekunuts",
    "__dummy__Object_Bank_OE3",
    "__dummy__Object_Bank_OE4",
    "__dummy__Object_Bank_Menkuri_Objects",
    "__dummy__Object_Bank_OE5",
    "__dummy__Object_Bank_OE6",
    "__dummy__Object_Bank_OE7",
    "__dummy__Object_Bank_OE8",
    "__dummy__Object_Bank_OE9",
    "__dummy__Object_Bank_OE10",
    "__dummy__Object_Bank_OE11",
    "__dummy__Object_Bank_OE12",
    "__dummy__Object_Bank_Vali",
    "__dummy__Object_Bank_OA10",
    "__dummy__Object_Bank_OA11",
    "__dummy__Object_Bank_fHG",
    "__dummy__Object_Bank_Ossan",
    "Object_Bank_Bb",
    "Object_Bank_Death",
    "__dummy__Object_Bank_Zl2",
    "__dummy__Object_Bank_Mjin",
    "__dummy__Object_Bank_Mjin_flash",
    "__dummy__Object_Bank_Mjin_dark",
    "__dummy__Object_Bank_Mjin_flame",
    "__dummy__Object_Bank_Mjin_ice",
    "__dummy__Object_Bank_Mjin_soul",
    "__dummy__Object_Bank_Mjin_wind",
    "__dummy__Object_Bank_Mjin_oka",
    "Object_Bank_F40_Obj",
    "Object_Bank_Po_Composer",
    "__dummy__Object_Bank_Warp2",
    "Object_Bank_Hata",
    "__dummy__Object_Bank_Bird",
    "Object_Bank_Wood02",
    "__dummy__Object_Bank_Lightbox",
    "__dummy__Object_Bank_Pu_box",
    "Object_Bank_Trap",
    "__dummy__Object_Bank_Vase",
    "__dummy__Object_Bank_Im",
    "__dummy__Object_Bank_Ta",
    "__dummy__Object_Bank_Tk",
    "__dummy__Object_Bank_Xc",
    "Object_Bank_Vm",
    "__dummy__Object_Bank_Bv",
    "__dummy__Object_Bank_efc_crystal_light",
    "__dummy__Object_Bank_efc_fire_ball",
    "__dummy__Object_Bank_Flash",
    "__dummy__Object_Bank_efc_lgt_shower",
    "Object_Bank_efc_star_field",
    "__dummy__Object_Bank_god_lgt",
    "__dummy__Object_Bank_light_ring",
    "__dummy__Object_Bank_triforce_spot",
    "__dummy__Object_Bank_Sd",
    "Object_Bank_Rd",
    "Object_Bank_Yukimura_Obj",
    "__dummy__Object_Bank_Heavy_Object",
    "__dummy__Object_Bank_Gnd",
    "__dummy__Object_Bank_Boss_Fd",
    "__dummy__Object_Bank_Du",
    "__dummy__Object_Bank_Fd",
    "__dummy__Object_Bank_medal",
    "Object_Bank_Horse_Link_Child",
    "__dummy__Object_Bank_Haka",
    "__dummy__Object_Bank_Ru1",
    "Object_Bank_Syokudai",
    "__dummy__Object_Bank_Boss_Fd2",
    "__dummy__Object_Bank_Dh",
    "__dummy__Object_Bank_Rl",
    "Object_Bank_efc_tw",
    "__dummy__Object_Bank_Demo_Tre_Lgt",
    "Object_Bank_Gi_Key",
    "Object_Bank_Mir_Ray",
    "Object_Bank_Ctower_Rot",
    "__dummy__Object_Bank_Gi_Jewel",
    "Object_Bank_Bdoor",
    "__dummy__Object_Bank_Shop_Tana",
    "__dummy__Object_Bank_Nb",
    "__dummy__Object_Bank_Mo",
    "Object_Bank_Sb",
    "Object_Bank_Gi_Melody",
    "Object_Bank_Gi_Heart",
    "Object_Bank_Gi_Compass",
    "Object_Bank_Gi_Bosskey",
    "__dummy__Object_Bank_Gi_Medal",
    "Object_Bank_Gi_Nuts",
    "__dummy__Object_Bank_Sa",
    "Object_Bank_Gi_Hearts",
    "Object_Bank_Gi_Arrowcase",
    "Object_Bank_Gi_Bombpouch",
    "Object_Bank_In",
    "__dummy__Object_Bank_Tr",
    "__dummy__Object_Bank_OE1s",
    "__dummy__Object_Bank_OE4s",
    "Object_Bank_OEs_anime",
    "Object_Bank_Gi_Bottle",
    "Object_Bank_Gi_Stick",
    "Object_Bank_Gi_Map",
    "Object_Bank_OF1d_Map",
    "Object_Bank_Ru2",
    "__dummy__Object_Bank_Gi_Shield_1",
    "Object_Bank_Gi_Magicpot",
    "Object_Bank_Gi_Bomb_1",
    "__dummy__Object_Bank_OF1s",
    "Object_Bank_Ma2",
    "Object_Bank_Gi_Purse",
    "__dummy__Object_Bank_Hni",
    "__dummy__Object_Bank_Tw",
    "Object_Bank_Rr",
    "__dummy__Object_Bank_Bxa",
    "__dummy__Object_Bank_Anubice",
    "__dummy__Object_Bank_Gi_Gerudo",
    "Object_Bank_Gi_Arrow",
    "Object_Bank_Gi_Bomb_2",
    "__dummy__Object_Bank_Gi_Egg",
    "__dummy__Object_Bank_Gi_Scale",
    "Object_Bank_Gi_Shield_2",
    "Object_Bank_Gi_Hookshot",
    "Object_Bank_Gi_Ocarina",
    "Object_Bank_Gi_Milk",
    "Object_Bank_Ma1",
    "__dummy__Object_Bank_Ganon",
    "__dummy__Object_Bank_Sst",
    "__dummy__Object_Bank_Go2",
    "Object_Bank_Ny",
    "Object_Bank_Fr",
    "__dummy__Object_Bank_Gi_Pachinko",
    "__dummy__Object_Bank_Gi_Boomerang",
    "Object_Bank_Gi_Bow",
    "Object_Bank_Gi_Glasses",
    "Object_Bank_Gi_Liquid",
    "Object_Bank_Ani",
    "Object_Bank_Gi_Shield_3",
    "__dummy__Object_Bank_Gi_Letter",
    "__dummy__Object_Bank_Gi_Clothes",
    "Object_Bank_Gi_Bean",
    "Object_Bank_Gi_Fish",
    "__dummy__Object_Bank_Gi_Saw",
    "__dummy__Object_Bank_Gi_Hammer",
    "__dummy__Object_Bank_Gi_Grass",
    "Object_Bank_Gi_Longsword",
    "__dummy__Object_Bank_Gate",
    "__dummy__Object_Bank_Md",
    "__dummy__Object_Bank_Km1",
    "__dummy__Object_Bank_Kw1",
    "Object_Bank_Zo",
    "__dummy__Object_Bank_Kzdd",
    "Object_Bank_Umajump",
    "__dummy__Object_Bank_Masterkokiri",
    "__dummy__Object_Bank_Masterkokirihead",
    "Object_Bank_Mastergolon",
    "Object_Bank_Masterzoora",
    "Object_Bank_Aob",
    "Object_Bank_Ik",
    "Object_Bank_Ahg",
    "Object_Bank_Cne",
    "__dummy__Object_Bank_Gi_Niwatori",
    "__dummy__Object_Bank_Skj",
    "Object_Bank_An3",
    "Object_Bank_Bji",
    "Object_Bank_Bba",
    "Object_Bank_An2",
    "__dummy__Object_Bank_Ds",
    "Object_Bank_An1",
    "Object_Bank_Boj",
    "Object_Bank_Fz",
    "Object_Bank_Bob",
    "Object_Bank_Ge1",
    "Object_Bank_Yabusame_Point",
    "__dummy__Object_Bank_Gi_Boots_2",
    "__dummy__Object_Bank_Gi_Seed",
    "__dummy__Object_Bank_Gnd_Magic",
    "__dummy__Object_Bank_D_Elevator",
    "Object_Bank_D_Hsblock",
    "Object_Bank_D_lift",
    "Object_Bank_Mamenoki",
    "Object_Bank_Goroiwa",
    "Object_Bank_Toryo",
    "Object_Bank_Daiku",
    "Object_Bank_Nwc",
    "Object_Bank_Gm",
    "Object_Bank_Ms",
    "Object_Bank_Hs",
    "__dummy__Object_Bank_Ingate",
    "Object_Bank_Lightswitch",
    "Object_Bank_Kusa",
    "Object_Bank_Tsubo",
    "__dummy__Object_Bank_Gi_Gloves",
    "__dummy__Object_Bank_Gi_Coin",
    "Object_Bank_Kanban",
    "Object_Bank_Owl",
    "Object_Bank_Mk",
    "Object_Bank_Fu",
    "Object_Bank_Gi_Ki_Tan_Mask",
    "__dummy__Object_Bank_Gi_Redead_Mask",
    "Object_Bank_Gi_Skj_Mask",
    "Object_Bank_Gi_Rabit_Mask",
    "Object_Bank_Gi_Truth_Mask",
    "__dummy__Object_Bank_Siofuki",
    "Object_Bank_Stream",
    "Object_Bank_Mm",
    "__dummy__Object_Bank_Fa",
    "__dummy__Object_Bank_Os",
    "__dummy__Object_Bank_Gi_Eye_Lotion",
    "__dummy__Object_Bank_Gi_Powder",
    "__dummy__Object_Bank_Gi_Mushroom",
    "__dummy__Object_Bank_Gi_Ticketstone",
    "__dummy__Object_Bank_Gi_Brokensword",
    "Object_Bank_Js",
    "Object_Bank_Cs",
    "__dummy__Object_Bank_Gi_Prescription",
    "__dummy__Object_Bank_Gi_Bracelet",
    "Object_Bank_Gi_Soldout",
    "__dummy__Object_Bank_Gi_Frog",
    "Object_Bank_Mag",
    "__dummy__Object_Bank_Efc_Erupc",
    "__dummy__Object_Bank_Zl2_Anime1",
    "__dummy__Object_Bank_Zl2_Anime2",
    "Object_Bank_Gi_Golonmask",
    "Object_Bank_Gi_Zoramask",
    "__dummy__Object_Bank_Gi_Gerudomask",
    "__dummy__Object_Bank_Ganon2",
    "Object_Bank_Ka",
    "__dummy__Object_Bank_Ts",
    "Object_Bank_Zg",
    "__dummy__Object_Bank_Gi_Hoverboots",
    "Object_Bank_Gi_M_Arrow",
    "Object_Bank_Ds2",
    "__dummy__Object_Bank_Ec",
    "Object_Bank_Fish",
    "Object_Bank_Gi_Sutaru",
    "__dummy__Object_Bank_Gi_Goddess",
    "Object_Bank_Ssh",
    "Object_Bank_Bigslime",
    "Object_Bank_Bg",
    "Object_Bank_Bombiwa",
    "Object_Bank_Hintnuts",
    "Object_Bank_Rs",
    "__dummy__Object_Bank_Spot00_Break",
    "Object_Bank_Gla",
    "__dummy__Object_Bank_Shopnuts",
    "Object_Bank_Gelb",
    "__dummy__Object_Bank_Gr",
    "Object_Bank_Dog",
    "Object_Bank_Kibako2",
    "Object_Bank_Dns",
    "Object_Bank_Dnk",
    "__dummy__Object_Bank_Gi_Fire",
    "Object_Bank_Gi_Insect",
    "__dummy__Object_Bank_Gi_Butterfly",
    "Object_Bank_Gi_Ghost",
    "Object_Bank_Gi_Soul",
    "__dummy__Object_Bank_Gi_Dekupouch",
    "__dummy__Object_Bank_Ganon_Anime1",
    "__dummy__Object_Bank_Ganon_Anime2",
    "__dummy__Object_Bank_Ganon_Anime3",
    "Object_Bank_Gi_Rupy",
    "Object_Bank_Mu",
    "Object_Bank_Wf",
    "Object_Bank_Skb",
    "Object_Bank_Gs",
    "Object_Bank_Ps",
    "Object_Bank_Bwall",
    "Object_Bank_Cow",
    "__dummy__Object_Bank_Cob",
    "Object_Bank_Gi_Sword_1",
    "__dummy__Object_Bank_Door_Killer",
    "__dummy__Object_Bank_Timeblock",
    "Object_Bank_Zl4",
    "Object_Bank_Link_Goron",
    "Object_Bank_Link_Zora",
    "Object_Bank_Grasshopper",
    "Object_Bank_Boyo",
    "__dummy__Object_Bank_Fence",
    "__dummy__Object_Bank_Hampost",
    "__dummy__Object_Bank_Swfl",
    "Object_Bank_Fire_wall",
    "Object_Bank_Link_Nuts",
    "Object_Bank_Jso",
    "Object_Bank_Knight",
    "Object_Bank_Icicle",
    "Object_Bank_Spdweb",
    "__dummy__Object_Bank_Yh",
    "Object_Bank_Boss01",
    "Object_Bank_Boss02",
    "Object_Bank_Boss03",
    "Object_Bank_Boss04",
    "Object_Bank_Boss05",
    "Object_Bank_Boss06",
    "Object_Bank_Boss07",
    "Object_Bank_Raf",
    "Object_Bank_Funen",
    "Object_Bank_Raillift",
    "Object_Bank_Numa_Obj",
    "Object_Bank_Flowerpot",
    "Object_Bank_Spinyroll",
    "Object_Bank_Ice_Block",
    "__dummy__Object_Bank_Dblue_Room",
    "Object_Bank_Op_map",
    "Object_Bank_Slime",
    "Object_Bank_Pr",
    "Object_Bank_F52_Obj",
    "Object_Bank_F53_Obj",
    "__dummy__Object_Bank_Yama_Obj",
    "Object_Bank_Kibako",
    "Object_Bank_Tsg",
    "Object_Bank_Gmo",
    "Object_Bank_Bat",
    "Object_Bank_SekihiL",
    "Object_Bank_SekihiG",
    "Object_Bank_SekihiN",
    "Object_Bank_SekihiZ",
    "__dummy__Object_Bank_Dnc",
    "Object_Bank_Wiz",
    "Object_Bank_Ladder",
    "Object_Bank_Mkk",
    "__dummy__Object_Bank_Skje",
    "__dummy__Object_Bank_Stain",
    "__dummy__Object_Bank_M_Stone",
    "Object_Bank_Keikoku_Obj",
    "Object_Bank_Sichitai_Obj",
    "Object_Bank_Dekucity_Ana_Obj",
    "Object_Bank_Rat",
    "Object_Bank_Water_Effect",
    "__dummy__Object_Bank_TimeTime",
    "Object_Bank_Dblue_Object",
    "Object_Bank_Bal",
    "Object_Bank_Warp_Uzu",
    "Object_Bank_Driftice",
    "Object_Bank_Fall",
    "Object_Bank_Hanareyama_Obj",
    "Object_Bank_Crace_Object",
    "Object_Bank_Dno",
    "Object_Bank_Obj_Moguri",
    "Object_Bank_Eg",
    "Object_Bank_Tru",
    "Object_Bank_Trt",
    "Object_Bank_Hakugin_Obj",
    "Object_Bank_Horse_Game_Check",
    "Object_Bank_Stk",
    "__dummy__Object_Bank_Hakugin_051",
    "__dummy__Object_Bank_Hakugin_081",
    "Object_Bank_Mnk",
    "Object_Bank_Gi_Bottle_Red",
    "Object_Bank_Tokei_Tobira",
    "Object_Bank_Az",
    "Object_Bank_Twig",
    "Object_Bank_Dekucity_Obj",
    "Object_Bank_Po_Fusen",
    "Object_Bank_Racetsubo",
    "Object_Bank_Ha",
    "Object_Bank_Bigokuta",
    "Object_Bank_Open_Obj",
    "Object_Bank_Fu_Kaiten",
    "Object_Bank_Fu_Mato",
    "Object_Bank_Mtoride",
    "Object_Bank_Osn",
    "Object_Bank_Tokei_Step",
    "Object_Bank_Lotus",
    "Object_Bank_Tl",
    "Object_Bank_Dkjail_Obj",
    "Object_Bank_Visiblock",
    "Object_Bank_Tsn",
    "Object_Bank_Ds2n",
    "Object_Bank_Fsn",
    "Object_Bank_Shn",
    "Object_Bank_Bigicicle",
    "Object_Bank_Gi_Bottle_15",
    "Object_Bank_Tk",
    "Object_Bank_Market_Obj",
    "Object_Bank_Gi_Moon_Stone",
    "Object_Bank_Gi_Kenrisyo",
    "Object_Bank_Lightblock",
    "Object_Bank_Takaraya_Objects",
    "Object_Bank_Wdhand",
    "Object_Bank_Sdn",
    "Object_Bank_Snowwd",
    "Object_Bank_Giant",
    "Object_Bank_Comb",
    "Object_Bank_Hana",
    "Object_Bank_Boss_Hakugin",
    "Object_Bank_Meganeana_Obj",
    "Object_Bank_Gi_Nutsmask",
    "Object_Bank_Stk2",
    "Object_Bank_Spot11_Obj",
    "Object_Bank_Danpei_Object",
    "Object_Bank_Dhouse",
    "Object_Bank_Hakaisi",
    "Object_Bank_Poh",
    "Object_Bank_Snowman",
    "Object_Bank_Po_Sisters",
    "Object_Bank_Pp",
    "Object_Bank_Goronswitch",
    "Object_Bank_Delf",
    "Object_Bank_Botihasira",
    "Object_Bank_Gi_Bigbomb",
    "Object_Bank_Pst",
    "Object_Bank_Bsmask",
    "Object_Bank_Spidertent",
    "Object_Bank_Zoraegg",
    "Object_Bank_Kbt",
    "Object_Bank_Gg",
    "Object_Bank_Maruta",
    "Object_Bank_Ghaka",
    "Object_Bank_Oyu",
    "Object_Bank_Dnq",
    "Object_Bank_Dai",
    "Object_Bank_Kgy",
    "Object_Bank_Fb",
    "Object_Bank_Taisou",
    "Object_Bank_Link_Mask_Bu_san",
    "Object_Bank_Link_Mask_Ki_Tan",
    "Object_Bank_Link_Mask_Rabit",
    "Object_Bank_Link_Mask_Skj",
    "Object_Bank_Link_Mask_Bakuretu",
    "Object_Bank_Link_Mask_Truth",
    "Object_Bank_Gk",
    "Object_Bank_Haka_Obj",
    "Object_Bank_Link_Mask_Goron",
    "Object_Bank_Link_Mask_Zora",
    "Object_Bank_Link_Mask_Nuts",
    "Object_Bank_Link_Mask_Boy",
    "Object_Bank_Dnt",
    "Object_Bank_Yukiyama",
    "Object_Bank_Icefloe",
    "Object_Bank_Gi_Gold_Dust",
    "Object_Bank_Gi_Bottle_16",
    "Object_Bank_Gi_Bottle_22",
    "Object_Bank_Bee",
    "Object_Bank_Ot",
    "Object_Bank_Utubo",
    "Object_Bank_Dora",
    "Object_Bank_Gi_Loach",
    "Object_Bank_Gi_Sea_Horse",
    "Object_Bank_Bigpo",
    "Object_Bank_Hariko",
    "Object_Bank_Dnj",
    "Object_Bank_Sinkai_Kabe",
    "Object_Bank_Kin2_Obj",
    "Object_Bank_Ishi",
    "Object_Bank_Hakugin_Demo",
    "Object_Bank_Jg",
    "Object_Bank_Gi_Sword_2",
    "Object_Bank_Gi_Sword_3",
    "Object_Bank_Gi_Sword_4",
    "Object_Bank_Obj_Um",
    "Object_Bank_Link_Mask_Gibudo",
    "Object_Bank_Link_Mask_Json",
    "Object_Bank_Link_Mask_Kerfay",
    "Object_Bank_Link_Mask_Bigelf",
    "Object_Bank_Rb",
    "Object_Bank_Mbar_Obj",
    "Object_Bank_Ikana_Obj",
    "Object_Bank_Kz",
    "Object_Bank_Tokei_Turret",
    "Object_Bank_Zog",
    "Object_Bank_Rotlift",
    "Object_Bank_Posthouse_Obj",
    "Object_Bank_Gi_Jsonmask",
    "Object_Bank_Gi_Bigelfmask",
    "Object_Bank_Gi_Gibudomask",
    "Object_Bank_Inibs_Object",
    "Object_Bank_Tree",
    "Object_Bank_Kaizoku_Obj",
    "Object_Bank_Gi_Inn_Key",
    "Object_Bank_Gi_C_Letter",
    "Object_Bank_Zob",
    "Object_Bank_Milkbar",
    "Object_Bank_Dmask",
    "Object_Bank_Link_Mask_Kyojin",
    "Object_Bank_Gi_Pendant",
    "Object_Bank_Zod",
    "Object_Bank_Kumo30",
    "Object_Bank_Yasi",
    "Object_Bank_Link_Mask_Romerny",
    "Object_Bank_Tanron1",
    "Object_Bank_Tanron2",
    "Object_Bank_Tanron3",
    "Object_Bank_Gi_Mushroom2",
    "Object_Bank_Chan",
    "Object_Bank_Gi_Romanimask",
    "Object_Bank_Zos",
    "Object_Bank_Link_Mask_Posthat",
    "Object_Bank_F40_Switch",
    "Object_Bank_Lod_Moon",
    "Object_Bank_Tro",
    "Object_Bank_Gi_Posthat",
    "Object_Bank_Gi_Giantmask",
    "Object_Bank_Gi_Syatoromani",
    "Object_Bank_Gi_Picturebox",
    "Object_Bank_Kamejima",
    "Object_Bank_Hg",
    "Object_Bank_Zov",
    "Object_Bank_Hgdr",
    "__dummy__Object_Bank_Cs2",
    "__dummy__Object_Bank_Cs3",
    "__dummy__Object_Bank_Cs4",
    "Object_Bank_Dor01",
    "Object_Bank_Dor02",
    "Object_Bank_Dor03",
    "Object_Bank_Dor04",
    "Object_Bank_Last_Obj",
    "Object_Bank_Redead_Obj",
    "Object_Bank_Ikninside",
    "Object_Bank_Iknv_Obj",
    "Object_Bank_Pamera",
    "Object_Bank_HsStump",
    "Object_Bank_Zm",
    "Object_Bank_Big_Fwall",
    "Object_Bank_Secom_Obj",
    "Object_Bank_Hunsui",
    "Object_Bank_Uch",
    "Object_Bank_Tanron4",
    "Object_Bank_Tanron5",
    "Object_Bank_Dt",
    "Object_Bank_Gi_Yusyamask",
    "Object_Bank_Cha",
    "Object_Bank_Dinner",
    "Object_Bank_Gi_Sokutatsu",
    "Object_Bank_Lastday",
    "Object_Bank_Bai",
    "Object_Bank_In2",
    "Object_Bank_Ikndemo",
    "Object_Bank_Yb",
    "Object_Bank_Rz",
    "Object_Bank_Link_Mask_Zacho",
    "Object_Bank_Gi_Fieldmap",
    "Object_Bank_Link_Mask_Stone",
    "Object_Bank_Bjt",
    "Object_Bank_Taru",
    "Object_Bank_Moonston",
    "Object_Bank_Link_Mask_Bree",
    "Object_Bank_Gi_Techo",
    "Object_Bank_Gi_Stone_Mask",
    "Object_Bank_Zoraband",
    "Object_Bank_Kepn_Koya",
    "Object_Bank_Usiyane",
    "Object_Bank_Gi_Kerfay_Mask",
    "Object_Bank_Gi_Zacho_Mask",
    "Object_Bank_Gi_Bree_Mask",
    "Object_Bank_Nnh",
    "Object_Bank_Link_Mask_Gero",
    "Object_Bank_Link_Mask_Yofukasi",
    "Object_Bank_Link_Mask_Meoto",
    "Object_Bank_Link_Mask_Dancer",
    "Object_Bank_Kzsaku",
    "Object_Bank_Obj_Milk_Bin",
    "Object_Bank_Random_Obj",
    "Object_Bank_Kujiya",
    "Object_Bank_Kitan",
    "Object_Bank_Gi_Yofukashi_Mask",
    "Object_Bank_Gi_Ge_Ro_Mask",
    "Object_Bank_Astr_Obj",
    "Object_Bank_Bsb",
    "Object_Bank_Fall2",
    "Object_Bank_Sth",
    "Object_Bank_Gi_Sun_Mask",
    "Object_Bank_Smtower",
    "Object_Bank_Gi_Bakuretsu_Mask",
    "Object_Bank_Yado_Obj",
    "Object_Bank_Syoten",
    "Object_Bank_Moonend",
    "Object_Bank_Ob",
    "Object_Bank_Gi_Fairy",
    "Object_Bank_Obj_Danpeilift",
    "Object_Bank_Wdor01",
    "Object_Bank_Wdor02",
    "Object_Bank_Wdor03",
    "Object_Bank_Stk3",
    "Object_Bank_Kinsta1_Obj",
    "Object_Bank_Kinsta2_Obj",
    "Object_Bank_Bh",
    "Object_Bank_Wdor04",
    "Object_Bank_Wdor05",
    "Object_Bank_Gi_Dancer_Mask",
    "Object_Bank_Gi_Buusan_Mask",
    "Object_Bank_Lbfshot",
    "Object_Bank_Fusen",
    "Object_Bank_Ending_Obj",
    "Object_Bank_Gi_Meoto_Mask"};
    int setup[0x80]={0},offset2,offset3,object_list=0;
    unsigned char count=0, count2, object_count=0;
    int offset, loop, loop2, loop3;
    unsigned short day;
    if(read32(RAM,0x3C)==0x5A534A00)
    {
        offset=read32(RAM,0xC76510+func*0x10);
    }
    else
    {
        offset=read32(RAM,0xBA0BB0+func*0x14);
        if(func>=0x6E){return;}
    }
    int scene_depth=offset;
    int start_offset2=offset;
    scene_start=offset;
    exits(RAM,start_offset2,0,0,0,0);
    while(RAM[scene_depth]!=4)
    {
        scene_depth+=8;
    }
    unsigned char rooms=RAM[scene_depth+1];
    offset+=read32(RAM,scene_depth+4)&0xffffff;
    pick:
    if(rooms>1)
    {
        printf("Pick a room (0 - %d)\n?",rooms-1);
        scanf("%d",&scene_depth);
        if(scene_depth>=rooms){goto pick;}
    }
    else
    {
        scene_depth=0;
    }
    offset=read32(RAM,(int)(offset+scene_depth*8));
    int start_offset=offset;
    rooms=0;
    scan_again:
    if(count>0)
    {
        count=0;
        loop=0;
        exits(RAM,start_offset2,0,0,0,0);
    }
    scene_depth=offset;
    while(RAM[scene_depth]!=0x14)
    {
        switch(RAM[scene_depth])
        {
            case 0x01:
                count2=RAM[scene_depth+1];
                offset3=read32(RAM,scene_depth+4)&0xffffff;
                offset3+=start_offset;
                break;
            case 0x0B:
                object_count=RAM[scene_depth+1];
                object_list=read32(RAM,scene_depth+4)&0xffffff;
                object_list+=start_offset;
                break;
            case 0x18:
                offset2=0xC+(read32(RAM,scene_depth+4)&0xffffff);
                if(RAM[0x3f]==0)
                {
                    offset2=read32(RAM,scene_depth+4)&0xffffff;
                }
                offset2+=offset;
                while(rooms<4)
                {
                    rooms=RAM[offset2];
                    if(rooms!=3){break;}
                    setup[count]=(read32(RAM,offset2)&0xffffff)+offset;
                    count+=1;
                    offset2+=4;
                }
                break;
        }
        scene_depth+=8;
    }
    pick2:
    if(count>0)
    {
        printf("Use a setup? (0 - %d) (Enter %d to refuse!)\n",(count-1),count);
        scanf("%d",&scene_depth);
    }
    if(count>0&&scene_depth>=(count+1)){goto pick2;}
    if(count>0&&scene_depth<count)
    {
        offset=setup[scene_depth];
        loop=start_offset2;
        while(RAM[loop]!=0x14)
        {
            if(RAM[loop]==0x18)
            {
                offset2=0xC+(read32(RAM,loop+4)&0xffffff)+scene_depth*4;
                if(RAM[0x3f]==1)
                {
                    offset2=(read32(RAM,loop+4)&0xffffff)+scene_depth*4;
                }
                offset2+=start_offset2;
                start_offset2+=read32(RAM,offset2)&0xffffff;
                break;
            }
            loop+=8;
        }
        goto scan_again;
    }
    printf("%08X (%08X)\n",start_offset2-scene_start,start_offset2);
    doors(RAM,DEMO,start_offset2,zenum_add,zenum_sym);
    exits(RAM,start_offset2,2,0,0,0);
    if(read32(RAM,0x3C)==0x5A534A00)
    {
        goto majora;
    }
    for(scene_depth=0;scene_depth<count2;scene_depth+=1)
    {
        for(offset=0;offset<0x1AD;offset+=1)
        {
            if((unsigned short)((RAM[offset3+scene_depth*16]<<8)|RAM[1+offset3+scene_depth*16])==zenum_add[offset])
            {
                printf("%08X %s\n",(offset3+scene_depth*16),zenum_sym[offset]);
                switch(zenum_add[offset])
                {
                    case 0x39:
                        if(RAM[15+offset3+scene_depth*16]==9||RAM[15+offset3+scene_depth*16]==10)
                        {
                            message_set(RAM,0x300+RAM[14+offset3+scene_depth*16]);
                        }
                        break;
                    case 0x141:
                        message_set(RAM,0x300+RAM[15+offset3+scene_depth*16]);
                        break;
                    case 0x11B:
                        message_set(RAM,0x100+RAM[15+offset3+scene_depth*16]);
                        break;
                    case 0x185:
                        message_set(RAM,0x200+(unsigned char)((RAM[14+offset3+scene_depth*16]<<2)|(RAM[15+offset3+scene_depth*16]>>6)));
                        break;
                    case 0x1B9:
                        message_set(RAM,0x400+RAM[15+offset3+scene_depth*16]);
                }
                break;
            }
        }
    }
    for(loop=object_list;loop<(object_list+object_count*2);loop+=2)
    {
        loop2=read32(RAM,0xB9E6C8+(unsigned short)((RAM[loop]<<8)|RAM[loop+1])*8);
        for(loop3=0x12F70;loop3<0x18F30;loop3+=0x10)
        {
            if(read32(RAM,loop3)==loop2)
            {
                printf("%08X %s\n",loop,pointers[(loop3-0x12F70)/0x10]);
                break;
            }
        }
    }
    return;
    majora:
    for(scene_depth=0;scene_depth<count2;scene_depth+=1)
    {
        for(offset=0x1AD;offset<0x3EC;offset+=1)
        {
            if((unsigned short)(((RAM[offset3+scene_depth*16]&0xF)<<8)|RAM[1+offset3+scene_depth*16])==zenum_add[offset])
            {
                if(zenum_add[offset]!=0xEF)
                {
                    day=(unsigned short)(((RAM[9+offset3+scene_depth*16]&7)<<7)|(RAM[13+offset3+scene_depth*16]&0x7F));
                    printf("%08X ",(offset3+scene_depth*16));
                    if((day&(unsigned short)(1<<9))==(unsigned short)(1<<9))
                    {
                        printf("Day 0 | ");
                    }
                    if((day&(unsigned short)(1<<8))==(unsigned short)(1<<8))
                    {
                        printf("Night 0 | ");
                    }
                    if((day&(unsigned short)(1<<7))==(unsigned short)(1<<7))
                    {
                        printf("Day 1 | ");
                    }
                    if((day&(unsigned short)(1<<6))==(unsigned short)(1<<6))
                    {
                        printf("Night 1 | ");
                    }
                    if((day&(unsigned short)(1<<5))==(unsigned short)(1<<5))
                    {
                        printf("Day 2 | ");
                    }
                    if((day&(unsigned short)(1<<4))==(unsigned short)(1<<4))
                    {
                        printf("Night 2 | ");
                    }
                    if((day&(unsigned short)(1<<3))==(unsigned short)(1<<3))
                    {
                        printf("Day 3 | ");
                    }
                    if((day&(unsigned short)(1<<2))==(unsigned short)(1<<2))
                    {
                        printf("Night 3 | ");
                    }
                    if((day&(unsigned short)(1<<1))==(unsigned short)(1<<1))
                    {
                        printf("Day 4 | ");
                    }
                    if((day&1)==1)
                    {
                        printf("Night 4 ");
                    }
                    printf("%s\n",zenum_sym[offset]);
                }
                switch(zenum_add[offset])
                {
                    case 0x26:
                        if(RAM[15+offset3+scene_depth*16]==9||RAM[15+offset3+scene_depth*16]==10)
                        {
                            message_set(DEMO,0x300+RAM[14+offset3+scene_depth*16]);
                        }
                        break;
                    case 0xA8:
                        message_set(DEMO,0x300+(unsigned short)((RAM[14+offset3+scene_depth*16]<<8)|RAM[15+offset3+scene_depth*16]));
                        break;
                    case 0xEF:
                        printf("%08X En_Gs ",(offset3+scene_depth*16));
                        //printf("GOSSIP STONE\n");
                        if((RAM[14+offset3+scene_depth*16]&0xF0)==0)
                        {
                            printf("(ENGS_0)\n");
                            message_set(DEMO,0x20D3+(RAM[15+offset3+scene_depth*16]&0x1F));
                        }
                        if((RAM[14+offset3+scene_depth*16]&0xF0)==0x10)
                        {
                            printf("(ENGS_1)\n");
                            message_set(DEMO,0x20F3+(RAM[15+offset3+scene_depth*16]&0x1F));
                        }
                        if((RAM[14+offset3+scene_depth*16]&0xF0)==0x20)
                        {
                            printf("(ENGS_2)\n");
                            message_set(DEMO,0x20F7+(RAM[15+offset3+scene_depth*16]&0x1F));
                        }
                        if((RAM[14+offset3+scene_depth*16]&0xF0)==0x30)
                        {
                            printf("(ENGS_3)\n");
                            message_set(DEMO,0x20B0+(RAM[15+offset3+scene_depth*16]&0x1F));
                        }
                        break;
                    case 0x146:
                        message_set(DEMO,RAM[15+offset3+scene_depth*16]);
                        break;
                    case 0x1D7:
                        message_set(DEMO,RAM[15+offset3+scene_depth*16]);
                        break;
                    case 0x261:
                        message_set(DEMO,0x1C00+(RAM[15+offset3+scene_depth*16]&0x3F));
                        break;
                }
                break;
            }
        }
    }
    for(loop=object_list;loop<(object_list+object_count*2);loop+=2)
    {
        printf("%08X %s\n",loop,objects[(unsigned short)((RAM[loop]<<8)|RAM[loop+1])]);
    }
}

int ovl_funcs[4]={0}, ovl_tracker;

int main(int argc, char **argv)
{
    const char names[32][3]=
    {
        "r0", "at", "v0", "v1",
        "a0", "a1", "a2", "a3",
        "t0", "t1", "t2", "t3",
        "t4", "t5", "t6", "t7",
        "s0", "s1", "s2", "s3",
        "s4", "s5", "s6", "s7",
        "t8", "t9", "k0", "k1",
        "gp", "sp", "fp", "ra"
    };
    char choice[2], filename[9], code[5]={0};
    FILE *ROM=fopen(argv[1],"rb");
    unsigned int CPU[32]={0}, inst=0, tgt;
    int addr_db[8192],base[2]={0x1000, 0x738C0},num=0,func_end=0,sum=0,addr,func,pc,loop;
    int zenum_add[8192],prev_tgt=0,znum=0,add,ext; //426 MM
    char LUIWATCH[32]={0},symb[64],symb_db[8192][64],zenum_sym[8192][128],actor[33],mode=CART;
    fseek(ROM,0,SEEK_END);
    int end=ftell(ROM);
    fseek(ROM,0,SEEK_SET);
    unsigned char *RAM=malloc(end);
    fread(RAM,1,end,ROM);
    fclose(ROM);
    FILE *ROM2=fopen("rom_out_mm_preview.z64","rb");
    fseek(ROM2,0,SEEK_END);
    end=ftell(ROM2);
    fseek(ROM2,0,SEEK_SET);
    unsigned char *DEMO=malloc(end);
    fread(DEMO,1,end,ROM2);
    fclose(ROM2);
    if(read32(RAM,0x3C)==0x5A4C450F)
    {
        RAM[0xB8D721]=0xBC;RAM[0xB8D722]=0xFA;RAM[0xB8D723]=0xC0;
        RAM[0xB8D725]=0xBD;RAM[0xB8D726]=0x2B;RAM[0xB8D727]=0x20;
        RAM[0xB8D729]=0x80;RAM[0xB8D72A]=0x0B;RAM[0xB8D72B]=0x90;

        RAM[0xB8D461]=0xBC;RAM[0xB8D462]=0xEF;RAM[0xB8D463]=0x30;
        RAM[0xB8D465]=0xBC;RAM[0xB8D466]=0xFA;RAM[0xB8D467]=0xC0;
        RAM[0xB8D469]=0x80;

        RAM[0xB8D4A1]=0xBD;RAM[0xB8D4A2]=0x2B;RAM[0xB8D4A3]=0x20;
        RAM[0xB8D4A5]=0xBD;RAM[0xB8D4A6]=0x2C;RAM[0xB8D4A7]=0x70;
        RAM[0xB8D4A9]=0x80;RAM[0xB8D4AA]=0x3B;RAM[0xB8D4AB]=0xF0;

        RAM[0xB8D4E1]=0xBD;RAM[0xB8D4E2]=0x2C;RAM[0xB8D4E3]=0x70;
        RAM[0xB8D4E5]=0xBE;RAM[0xB8D4E6]=0x27;RAM[0xB8D4E7]=0x30;
        RAM[0xB8D4E9]=0x80;RAM[0xB8D4EA]=0x3D;RAM[0xB8D4EB]=0x40;

        RAM[0xB8D501]=0xC2;RAM[0xB8D502]=0x79;RAM[0xB8D503]=0x40;
        RAM[0xB8D505]=0xC2;RAM[0xB8D506]=0xE4;RAM[0xB8D507]=0x20;
        RAM[0xB8D509]=0x85;RAM[0xB8D50A]=0x8B;RAM[0xB8D50B]=0x70;

        RAM[0xB8D6E1]=0xBE;RAM[0xB8D6E2]=0x27;RAM[0xB8D6E3]=0x30;
        RAM[0xB8D6E5]=0xC0;RAM[0xB8D6E6]=0x10;RAM[0xB8D6E7]=0xB0;
        RAM[0xB8D6E9]=0x81;RAM[0xB8D6EA]=0x38;RAM[0xB8D6EB]=0x20;

        RAM[0xB8D441]=0xC0;RAM[0xB8D442]=0x10;RAM[0xB8D443]=0xB0;
        RAM[0xB8D445]=0xC2;RAM[0xB8D446]=0x79;RAM[0xB8D447]=0x40;
        RAM[0xB8D449]=0x83;RAM[0xB8D44A]=0x22;RAM[0xB8D44B]=0x10;
        addr=0xBE80;
        for(loop=0;loop<1532;loop+=1)
        {
            add=0;
            while(RAM[addr]!=0)
            {
                pointers[loop][add]=RAM[addr];
                add+=1;
                addr+=1;
            }
            while(RAM[addr]==0)
            {
                addr+=1;
            }
        }
    }
    if(RAM[0]!=0x80){mode=DISK;}
    if(mode==CART)
    {
        code[0]=RAM[0x3C];
        code[1]=RAM[0x3D];
        code[2]=RAM[0x3E];
        code[3]=RAM[0x3F];
        if(code[0]==0)
        {
            code[0]=RAM[0x20];
            code[1]=RAM[0x21];
            code[2]=RAM[0x22];
            code[3]=RAM[0x23];
            if(read32(RAM,0x10)==0xA04237B9)
            {
                code[0]=0x57;
                code[1]=0x69;
                code[2]=0x6C;
                code[3]=0x64;
            }
            if(read32(RAM,0x20)==0x53796432&&read32(RAM,0x10)!=0x80A78080)
            {
                return -1;
            }
            goto after;
        }
    }
    else
    {
        code[0]=RAM[0x43670];
        code[1]=RAM[0x43671];
        code[2]=RAM[0x43672];
        code[3]=RAM[0x43673];
        if(code[0]==0)
        {
            if(read32(RAM,0x738C8)==0x25085690)
            {
                code[0]=0x44;
                code[1]=0x53;
                code[2]=0x4D;
                code[3]=0x4A;
            }
            else
            {
                code[0]=0x54;
                code[1]=0x45;
                code[2]=0x53;
                code[3]=0x54;
            }
        }
        goto after;
    }
    if(code[3]<0xA)
    {
        code[3]+=0x30;
    }
    else
    {
        code[3]+=0x37;
    }
    after:
    if(code[0]==0){return -1;}
    sprintf(filename,"%s.txt",code);
    FILE *symbols=fopen(filename,"r");
    while(!feof(symbols))
    {
        fscanf(symbols,"%x %s\n",&addr,symb);
        addr_db[num]=addr;
        strcpy(symb_db[num],symb);
        num+=1;
    }
    fclose(symbols);
    if((read32(RAM,0x3C)>>24)==0x5A)
    {
        FILE *zenum=fopen("znum.txt","r");
        while(!feof(zenum))
        {
            fscanf(zenum,"%x %s\n",&addr,symb);
            zenum_add[znum]=addr;
            strcpy(zenum_sym[znum],symb);
            znum+=1;
        }
        fclose(zenum);
    }
    if(mode==CART)
    {
        for(loop=0x40;loop<0x1000;loop+=1)
        {
            sum+=RAM[loop];
        }
        pc=read32(RAM,8)&0x1FFFFFFF;
        if(sum==0x357D0){pc-=0x100000;}
        if(sum==0x371CC){pc-=0x200000;}
    }
    else
    {
        pc=read32(RAM,0x1C)&0x1FFFFFFF;
        if(pc==0)
        {
            pc=read32(RAM,0x9A2C)&0x1FFFFFFF;
        }
    }
    unsigned char *REG=malloc(0x40000);
    again:
    add=0;
    if(ovl_funcs[0]>0||ovl_funcs[1]>0||ovl_funcs[2]>0||ovl_funcs[3]>0)
    {
        ovl_tracker+=1;
        while(ovl_funcs[ovl_tracker]==0)
        {
            ovl_tracker+=1;
        }
        if(ovl_tracker<4)
        {
            func=ovl_funcs[ovl_tracker];
            goto func_len;
        }
        ovl_funcs[0]=0;
        ovl_funcs[1]=0;
        ovl_funcs[2]=0;
        ovl_funcs[3]=0;
        ovl_tracker=0;
        goto choose;
    }
    printf("Where? ");
    scanf("%x",&func);
    if(read32(RAM,0x3C)==0x5A4C450F||read32(RAM,0x3C)==0x5A534A00)
    {
        if(func<113)
        {
        scene(RAM,DEMO,func,zenum_add,zenum_sym);
        goto choose;
        }
        if(func>=0x10AE670)
        {
            ovl_funcs[0]=0;
            ovl_funcs[1]=0;
            ovl_funcs[2]=0;
            ovl_funcs[3]=0;
            ovl_tracker=0;
            loop=((RAM[func]<<8)|RAM[1+func])&0xFFF;
            switch(RAM[0x3F])
            {
                case 0:
                    if(loop<=0x2B1)
                    {
                        addr=read32(RAM,0xC617D4+0x20*loop)&0xffffff;
                        add=read32(RAM,0xC617C0+0x20*loop);
                        add-=(read32(RAM,0xC617C8+0x20*loop)&0xffffff);
                        addr+=add+0x10;
                        ovl_funcs[0]=read32(RAM,addr+12)&0xffffff;
                        ovl_funcs[1]=read32(RAM,addr)&0xffffff;
                        ovl_funcs[2]=read32(RAM,addr+4)&0xffffff;
                        ovl_funcs[3]=read32(RAM,addr+8)&0xffffff;
                        while(ovl_funcs[ovl_tracker]==0)
                        {
                            ovl_tracker+=1;
                        }
                        if(ovl_funcs[0]>0){ovl_funcs[0]+=add;}
                        if(ovl_funcs[1]>0){ovl_funcs[1]+=add;}
                        if(ovl_funcs[2]>0){ovl_funcs[2]+=add;}
                        if(ovl_funcs[3]>0){ovl_funcs[3]+=add;}
                    }
                    break;
                case 15:
                    if(loop<=0x1D6)
                    {
                        addr=read32(RAM,0xB8D454+0x20*loop)&0xffffff;
                        add=read32(RAM,0xB8D440+0x20*loop);
                        add-=(read32(RAM,0xB8D448+0x20*loop)&0xffffff);
                        addr+=add+0x10;
                        ovl_funcs[0]=read32(RAM,addr+12)&0xffffff;
                        ovl_funcs[1]=read32(RAM,addr)&0xffffff;
                        ovl_funcs[2]=read32(RAM,addr+4)&0xffffff;
                        ovl_funcs[3]=read32(RAM,addr+8)&0xffffff;
                        while(ovl_funcs[ovl_tracker]==0)
                        {
                            ovl_tracker+=1;
                        }
                        if(ovl_funcs[0]>0){ovl_funcs[0]+=add;}
                        if(ovl_funcs[1]>0){ovl_funcs[1]+=add;}
                        if(ovl_funcs[2]>0){ovl_funcs[2]+=add;}
                        if(ovl_funcs[3]>0){ovl_funcs[3]+=add;}
                    }
            }
            add=0;
            if(ovl_funcs[ovl_tracker]>0)
            {
                func=ovl_funcs[ovl_tracker];
            }
        }
    }
    func_len:
    if(ovl_funcs[ovl_tracker]>0)
    {
        switch(ovl_tracker)
        {
            case 0:
                printf("\nactor->draw_proc\n");
                break;
            case 1:
                printf("\nactor->constract_proc\n");
                break;
            case 2:
                printf("\nactor->destruct_proc\n");
                break;
            case 3:
                printf("\nactor->move_proc\n");

        }
        system("pause");
    }
    if((func&3)!=0){goto again;}
    if(func<0x40||func>=end){goto again;}
    if(read32(RAM,0x3C)==0x5A4C450F||read32(RAM,0x3C)==0x5A534A00)
    {
        add=ovl_adapt(RAM,REG,DEMO,func,read32(RAM,0x3C));
        if(add>0)
        {
            ext=0;
            if(read32(RAM,0x3C)==0x5A4C450F)
            {
                goto ZL;
            }
            for(addr=0;addr<0x2B2;addr+=1)
            {
                if(func>=read32(RAM,0xDD5A50+0x20*addr)&&func<read32(RAM,0xDD5A54+0x20*addr))
                {
                    inst=0xAB7960+read32(RAM,0xDD5A68+0x20*addr);
                    break;
                }
            }
            goto skip;
            ZL:
            if(func>=0xD583E0&&func<0xD66150)
            {
                inst=0xCD60;
                goto skip;
            }
            for(addr=0;addr<0x1D7;addr+=1)
            {
                if(func>=read32(RAM,0xB8D440+0x20*addr)&&func<read32(RAM,0xB8D444+0x20*addr))
                {
                    inst=0xA771A0+read32(RAM,0xB8D458+0x20*addr);
                    break;
                }
            }
            skip:
            addr=1;
            while(addr!=0)
            {
                addr=RAM[inst+ext];
                actor[ext]=addr;
                ext+=1;
            }
        }
    }
    while(inst!=0x03E00008)
    {
        inst=read32(RAM,func+func_end);
        func_end+=4;
        if(inst==0x02A00008){break;}
    }
    func_end+=4;
    for(addr=0;addr<(func_end/4);addr+=1)
    {
        ext=0;
        tgt=func+addr*4;
        inst=read32(RAM,tgt);
        if(inst!=0&&op(inst)!=J&&op(inst)!=JAL&&op(inst)!=LUI&&op(inst)!=BNEL)
        {
            printf("%08X ",tgt);
        }
        switch(op(inst))
        {
            case SPECIAL:
                switch(funct(inst))
                {
                    case OR:
                        tgt=rd(inst);
                        CPU[tgt]=CPU[rs(inst)]|CPU[rt(inst)];
                        if(tgt>=S0&&tgt<T8)
                        {
                        if(rs(inst)>=A0&&rs(inst)<T0&&rt(inst)==R0)
                        {
                            if(read32(RAM,0x3C)==0x5A4C450F)
                            {
                                CPU[tgt]=0x80212020;
                            }
                        }
                        }
                        for(loop=0;loop<num;loop+=1)
                        {
                            if(addr_db[loop]==CPU[tgt])
                            {
                                if(CPU[tgt]>0xFFF&&tgt<T0)
                                {
                                    printf("%s = %s\n",names[tgt],symb_db[loop]);
                                    break;
                                }
                                else if(CPU[tgt]>0xFFF&&tgt>=T0)
                                {
                                    if(CPU[tgt]<0x80000000)
                                    {
                                        printf("%s = %s\n",names[tgt],symb_db[loop]);
                                        break;
                                    }
                                }
                                else
                                {
                                    if(tgt<T0)
                                    {
                                        printf("%s = 0x%X\n",names[tgt],CPU[tgt]);
                                        break;
                                    }
                                    else
                                    {
                                        if(CPU[tgt]<0x80000000)
                                        {
                                            printf("%08X\n",inst);
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                        if(loop==num)
                        {
                            if(tgt<T0)
                            {
                                printf("%s = 0x%X\n",names[tgt],CPU[tgt]);
                            }
                            else
                            {
                                printf("%08X\n",inst);
                            }
                        }
                        break;
                    default:
                        if(inst!=0)
                        {
                            printf("%08X\n",inst);
                        }
                        break;
                }
                break;
            case J:
            case JAL:
                tgt=(unsigned int)((inst&0x03ffffff)<<2);
                if(tgt<0x800000&&prev_tgt>=0x800000)
                {
                    system("pause");
                }
                prev_tgt=tgt;
                if(read32(RAM,0x3C)==0x242C343C&&tgt>=0x510000)
                {
                    if(read32(RAM,0x738C8)==0x25085690)
                    {
                        ext=1;
                        tgt-=0x3E70B0;
                    }
                    else
                    {
                        tgt-=pc;
                        tgt+=base[mode];
                    }
                }
                else if(read32(RAM,0x3C)==0x41464A00&&tgt>=0x051A80) //Doubutsu no Mori (Japan)
                {
                    if(tgt>>24==4)
                    {
                        if(func>=0x675720){tgt-=0x38E0090;}
                        else{tgt-=0x3FEA0C0;}
                    }
                    else
                    {
                        ext=1;
                        tgt+=0x623CA0;
                    }
                }
                else if(read32(RAM,0x3C)==0x46444500&&tgt>=0x4001000) //Flying Dragon
                {
                    tgt-=0x3F803E0;
                }
                else if(read32(RAM,0x3C)==0x465A4A00&&tgt>=0x4001000) //F-Zero X
                {
                    tgt-=0x3F9F620;
                }
                else if(read32(RAM,0x3C)==0x47354500&&tgt>=0x4001000) //Mystical Ninja Starring Goemon
                {
                    tgt-=0x3FADE00;
                }
                else if(read32(RAM,0x3C)==0x47414500&&tgt>=0x4001000) //Deadly Arts
                {
                    tgt-=0x3FD1BE0;
                }
                else if(read32(RAM,0x3C)==0x474D4500&&tgt>=0x4001000) //Goemon's Great Adventure
                {
                    tgt-=0x3FDBF40;
                }
                else if(read32(RAM,0x3C)==0x4B414500&&tgt>=0x4001000) //Fighter's Destiny
                {
                    tgt-=0x3FB88A0;
                }
                else if(read32(RAM,0x3C)==0x4B544A00&&tgt>=0x280000) //Mario Kart 64 (J) (V1.0) [!]
                {
                    if(tgt>>24==4)
                    {
                        tgt-=0x3F26B70;
                    }
                    else
                    {
                        ext=1;
                        tgt-=0x15BF90;    //map_ram(0x280000, 0x124070, 0x007490);
                        if(tgt+0x15BF90>=0x28DF00)
                        {
                            ext=2;
                            tgt-=0x39FB0; //map_ram(0x28DF00, 0x0F7FC0, 0x02C0B0);
                        }
                    }
                }
                else if(read32(RAM,0x3C)==0x4D454500&&tgt>=0x4001000) //Mace - The Dark Age
                {
                    tgt-=0x3F85C00;
                }
                else if(read32(RAM,0x3C)==0x4D514A00&&tgt>=0x0DC4E0) //Mario Story (Japan)
                {
                    if(tgt>>24==4)
                    {
                        tgt-=0x4000440;
                    }
                    else
                    {
                        ext=1;
                        tgt-=0x066B50;               //map_ram(0x0DC4E0, 0x075990, 0x030600);
                        if(tgt+0x066B50>=0x10F890)
                        {
                            ext=2;
                            tgt-=0x002DB0;           //map_ram(0x10F890, 0x0A5F90, 0x0037E0);
                            if(tgt+0x069900>=0x1148E0)
                            {
                                ext=3;
                                tgt-=0x001870;       //map_ram(0x1148E0, 0x0A9770, 0x041A30);
                                if(tgt+0x06B170>=0x2C3000)
                                {
                                    ext=4;
                                    tgt-=0x16CCF0;   //map_ram(0x2C3000, 0x0EB1A0, 0x017480);
                                }
                            }
                        }
                    }
                }
                else if(read32(RAM,0x3C)==0x534D4A00&&tgt>=0x378800) //Super Mario 64 (J) [!]
                {
                    if(tgt>>24==4)
                    {
                        tgt-=0x3F1BC90;
                    }
                    else
                    {
                        ext=1;
                        tgt-=0x2845F0; //map_ram(0x378800, 0x0F4210, 0x013490);
                    }
                }
                else if(read32(RAM,0x3C)==0x57414500&&tgt>=0x4001000) //War Gods
                {
                    tgt-=0x3F63240;
                }
                else if(read32(RAM,0x3C)==0x574F4500&&tgt>=0x4001000) //World Driver Championship
                {
                    tgt-=0x3F83D00;
                }
                else if(read32(RAM,0x3C)==0x5A4C450F&&tgt>=0x01CE60) //ZELOOTMA
                {
                    if(tgt>>24==4)
                    {
                        if(func>=0xA94000){tgt-=0x3477DA0;}
                        else{tgt-=0x3FF7090;}
                    }
                    else
                    {
                        if(add>0&&tgt>=0x800000)
                        {
                            tgt+=add;
                        }
                        else
                        {
                            ext=1;
                            tgt+=0xA771A0;
                        }
                    }
                }
                else if(read32(RAM,0x3C)==0x5A4C4A00&&tgt>=0x0110A0) //Zelda no Densetsu - Toki no Ocarina (Japan)
                {
                    if(tgt>>24==4)
                    {
                        tgt-=0x34A80E0;
                    }
                    else
                    {
                        ext=1;
                        tgt+=0xA75F60;
                    }
                }
                else if(read32(RAM,0x3C)==0x5A534A00&&tgt>=0x0A76A0) //mm_debug
                {
                    if(tgt>>24==4)
                    {
                        tgt-=0x322FA50;
                    }
                    else
                    {
                        if(add>0&&tgt>=0x800000)
                        {
                            tgt+=add;
                        }
                        else
                        {
                            ext=1;
                            tgt+=0xAB7960;
                        }
                    }
                }
                else
                {
                    tgt-=pc;
                    tgt+=base[mode];
                    if(func>=0xB8A210&&func<0xB8BAD0)   //S2DEX2
                    {
                        if(read32(RAM,0x3C)==0x5A4C450F)
                        {
                        if(tgt>=0x2A00)             //1E00 - 1FFF is static
                        {
                            tgt+=0xB88590;
                        }
                        if(tgt>=0x1C98&&tgt<0x22D0) //1180 - 16CF is static but
                        {                           //1098 doesn't have conflicts
                            tgt+=0xB88590;
                        }
                        }
                    }
                    if(func>=0xBCD0F0&&func<0xBCE720)   //F3DEX2
                    {
                        if(read32(RAM,0x3C)==0x5A4C450F)
                        {
                        if(tgt>=0x2380)             //1780 - 1FFF is static
                        {
                            tgt+=0xBCB470;
                        }
                        if(tgt>=0x1C00&&tgt<0x1D70) //1000 - 116F is ovl0, ovl1 and init
                        {
                            tgt+=0xBCC508;    //assume it's ovl1
                            if(tgt==0xBCE128) //fix 1020
                            {
                                tgt-=0x98;    //(the only part of ovl0 J/JAL'd to)
                            }
                            if(tgt==0xBCE270) //fix 1168
                            {
                                tgt-=0x1098;  //(the only part of init J/JAL'd to)
                            }
                        }
                        if(tgt>=0x1D70&&tgt<0x1ED8) //1170 - 12D7 is static
                        {
                            tgt+=0xBCB470;
                        }
                        if(tgt>=0x1ED8&&tgt<0x2380) //12D8 - 177F is ovl2 and ovl3
                        {
                            tgt+=0xBCC3A0;    //assume it's ovl2
                            if(tgt==0xBCE2C0) //fix 1320
                            {
                                tgt-=0xF30;   //(the only part of ovl3 J/JAL'd to)
                            }
                        }
                        }
                    }
                }
                ext=0;
                if(read32(RAM,0x3C)==0x5A4C450F)
                {
                    switch(tgt)
                    {
                        case 0xaa1b94:
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //",symb_db[loop]);}
                                    else{printf("JAL <%s> //",symb_db[loop]);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A2))
                            {
                                CPU[A2]=read32(RAM,func+(addr+1)*4)&0xffff;
                            }
                            for(loop=1004;loop<znum;loop+=1)
                            {
                                if(zenum_add[loop]==CPU[A2]||(zenum_add[loop]-0x800)==CPU[A2])
                                {
                                    if(zenum_add[loop]==CPU[A2])
                                    {
                                        printf(" %s\n",zenum_sym[loop]);
                                    }
                                    else if((zenum_add[loop]-0x800)==CPU[A2])
                                    {
                                        printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
                                    }
                                    break;
                                }
                            }
                            system("pause");
                            break;
                        case 0xAA697C:
                        case 0xAA69C8:
                        case 0xAA6A90:
                        case 0xAA6ABC:
                        case 0xAA6AE8:
                        case 0xAA6B14:
                        case 0xAEFAB4:
                        case 0xB6B50C:
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //",symb_db[loop]);}
                                    else{printf("JAL <%s> //",symb_db[loop]);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A1))
                            {
                                CPU[A1]=read32(RAM,func+(addr+1)*4)&0xffff;
                            }
                            for(loop=1004;loop<znum;loop+=1)
                            {
                                if(zenum_add[loop]==CPU[A1]||(zenum_add[loop]-0x800)==CPU[A1])
                                {
                                    if(zenum_add[loop]==CPU[A1])
                                    {
                                        printf(" %s\n",zenum_sym[loop]);
                                    }
                                    else if((zenum_add[loop]-0x800)==CPU[A1])
                                    {
                                        printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
                                    }
                                    break;
                                }
                            }
                            system("pause");
                            break;
                        case 0xAE2C78:
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //",symb_db[loop]);}
                                    else{printf("JAL <%s> //",symb_db[loop]);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A3))
                            {
                                CPU[A3]=read32(RAM,func+(addr+1)*4)&0xffff;
                            }
                            for(loop=1004;loop<znum;loop+=1)
                            {
                                if(zenum_add[loop]==CPU[A3]||(zenum_add[loop]-0x800)==CPU[A3])
                                {
                                    if(zenum_add[loop]==CPU[A3])
                                    {
                                        printf(" %s\n",zenum_sym[loop]);
                                    }
                                    else if((zenum_add[loop]-0x800)==CPU[A3])
                                    {
                                        printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
                                    }
                                    break;
                                }
                            }
                            system("pause");
                            break;
                        case 0xAEFA24:
                        case 0xAEFA6C:
                        case 0xB6E52C:
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //",symb_db[loop]);}
                                    else{printf("JAL <%s> //",symb_db[loop]);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A0))
                            {
                                CPU[A0]=read32(RAM,func+(addr+1)*4)&0xffff;
                            }
                            for(loop=1004;loop<znum;loop+=1)
                            {
                                if(zenum_add[loop]==CPU[A0]||(zenum_add[loop]-0x800)==CPU[A0])
                                {
                                    if(zenum_add[loop]==CPU[A0])
                                    {
                                        printf(" %s\n",zenum_sym[loop]);
                                    }
                                    else if((zenum_add[loop]-0x800)==CPU[A0])
                                    {
                                        printf(" %s - SFX_FLAG\n",zenum_sym[loop]);
                                    }
                                    break;
                                }
                            }
                            system("pause");
                            break;
                        case 0xAA90F0:
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
                                    else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A2))
                            {
                                CPU[A2]=read32(RAM,func+(addr+1)*4)&0xffff;
                            }
                            for(loop=0;loop<429;loop+=1)
                            {
                                if(zenum_add[loop]==CPU[A2])
                                {
                                    printf(" %s\n",zenum_sym[loop]);
                                    break;
                                }
                            }
                            break;
                        case 0xAA95F8:
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
                                    else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if(read32(RAM,func+(addr+1)*4)>>16==(0x2400|A3))
                            {
                                CPU[A3]=read32(RAM,func+(addr+1)*4)&0xffff;
                            }
                            for(loop=0;loop<429;loop+=1)
                            {
                                if(zenum_add[loop]==CPU[A3])
                                {
                                    printf(" %s\n",zenum_sym[loop]);
                                    break;
                                }
                            }
                            break;
                        case 0xB82820:
                            printf("%08X ",func+addr*4);
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
                                    else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            printf("\n");
                            message_set(RAM,CPU[A1]);
                            break;
                        case 0xB828C0:
                            printf("%08X ",func+addr*4);
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
                                    else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //%s",actor);
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if((read32(RAM,func+addr*4+4)>>16)==0x2405)
                            {
                                CPU[A1]=imm(read32(RAM,func+addr*4+4));
                            }
                            if(op(read32(RAM,func+addr*4+4))==ANDI)
                            {
                                CPU[rt(read32(RAM,func+addr*4+4))]=CPU[rs(read32(RAM,func+addr*4+4))]&imm(read32(RAM,func+addr*4+4));
                            }
                            printf("\n");
                            message_set(RAM,CPU[A1]);
                            break;
                    }
                }
                if(read32(RAM,0x3C)==0x5A534A00)
                {
                    switch(tgt)
                    {
                        case 0xC0A18C:
                            printf("%08X ",func+addr*4);
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(addr_db[loop]==tgt)
                                {
                                    if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
                                    else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
                                    break;
                                }
                            }
                            if(loop==num)
                            {
                                if(op(inst)==J){printf("J %08X",tgt);}
                                else{printf("JAL %08X",tgt);}
                                if(add>0&&tgt>=func-0x30000)
                                {
                                    printf(" //actor");
                                }
                                if(ext>0)
                                {
                                    printf(" //External file %d",ext);
                                }
                            }
                            ext=1;
                            if((read32(RAM,func+addr*4+4)>>16)==0x2405)
                            {
                                CPU[A1]=imm(read32(RAM,func+addr*4+4));
                            }
                            if(op(read32(RAM,func+addr*4+4))==ANDI)
                            {
                                CPU[rt(read32(RAM,func+addr*4+4))]=CPU[rs(read32(RAM,func+addr*4+4))]&imm(read32(RAM,func+addr*4+4));
                            }
                            printf("\n");
                            message_set(DEMO,CPU[A1]);
                            break;
                    }
                }
                if(ext!=1)
                {
                    printf("%08X ",func+addr*4);
                    for(loop=0;loop<num;loop+=1)
                    {
                        if(addr_db[loop]==tgt)
                        {
                            if(op(inst)==J){printf("J %s //%08X",symb_db[loop],tgt);}
                            else{printf("JAL <%s> //%08X",symb_db[loop],tgt);}
                            break;
                        }
                    }
                    if(loop==num)
                    {
                        if(op(inst)==J){printf("J %08X",tgt);}
                        else{printf("JAL %08X",tgt);}
                        if(add>0&&tgt>=func-0x30000)
                        {
                            if(read32(RAM,0x3C)==0x5A4C450F){printf(" //%s",actor);}
                            else{printf(" //actor");}
                        }
                        if(ext>0)
                        {
                            printf(" //External file %d",ext);
                        }
                    }
                    printf("\n");
                }
                ext=0;
                break;
            case BEQ:
                tgt=extend(imm(inst)<<2)+func+addr*4+4;
                if(rs(inst)==R0 && rt(inst)==R0)
                {
                    if(tgt<func+addr*4)
                    {
                        printf("break;   //%08X\n",tgt);
                    }
                    else
                    {
                        printf("(%s)\n",names[rs(inst)]);
                        printf("         case %s: //%08X\n",names[rt(inst)],tgt);
                    }
                }
                else
                {
                    printf("(%s)\n",names[rs(inst)]);
                    printf("         case %s: //%08X\n",names[rt(inst)],tgt);
                }
                break;
            case ADDIU:
                tgt=rt(inst);
                if((func+addr*4)==addiu_jump[0]||(func+addr*4)==(addiu_jump[0]+4))
                {
                    CPU[tgt]=addiu_jump[1];
                }
                CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
                for(loop=0;loop<num;loop+=1)
                {
                    if(addr_db[loop]==CPU[tgt])
                    {
                        if(CPU[tgt]>0xFFF&&tgt<T0)
                        {
                            if(CPU[tgt]<0x10000&&rs(inst)==R0){printf("%s = %s\n",names[tgt],symb_db[loop]);}
                            else
                            {
                                if(CPU[tgt]>=0x80000000){printf("%s = %s\n",names[tgt],symb_db[loop]);}
                                if(CPU[tgt]<0x80000000){printf("%s = 0x%X\n",names[tgt],CPU[tgt]);}
                            }
                            break;
                        }
                        else if(CPU[tgt]>0xFFF&&tgt>=T0)
                        {
                            if(CPU[tgt]<0x80000000)
                            {
                                printf("%s = %s\n",names[tgt],symb_db[loop]);
                                break;
                            }
                        }
                        else
                        {
                            if(tgt<T0)
                            {
                                printf("%s = 0x%X\n",names[tgt],CPU[tgt]);
                                break;
                            }
                            else
                            {
                                if(CPU[tgt]<0x80000000)
                                {
                                    printf("%08X\n",inst);
                                    break;
                                }
                            }
                        }
                    }
                }
                if(loop==num)
                {
                    if(CPU[tgt]>>24==0x80)
                    {
                        CPU[tgt]&=0x1FFFFFFF;
                        if(read32(RAM,0x3C)==0x242C343C&&CPU[tgt]>=0x510000)
                        {
                            if(read32(RAM,0x738C8)==0x25085690)
                            {
                                CPU[tgt]-=0x3E70B0;
                            }
                            else
                            {
                                CPU[tgt]-=pc;
                                CPU[tgt]+=base[mode];
                            }
                        }
                        else if(read32(RAM,0x3C)==0x41464A00&&CPU[tgt]>=0x051A80)
                        {
                            CPU[tgt]+=0x623CA0;
                        }
                        else if(read32(RAM,0x3C)==0x534D4A00&&CPU[tgt]>=0x378800)
                        {
                            CPU[tgt]-=0x2845F0;
                        }
                        else if(read32(RAM,0x3C)==0x5A4C450F&&CPU[tgt]>=0x01CE60)
                        {
                            if(add>0&&CPU[tgt]>=0x800000)
                            {
                                CPU[tgt]+=add;
                            }
                            else
                            {
                                CPU[tgt]+=0xA771A0;
                            }
                        }
                        else if(read32(RAM,0x3C)==0x5A4C4A00&&CPU[tgt]>=0x0110A0)
                        {
                            CPU[tgt]+=0xA75F60;
                        }
                        else if(read32(RAM,0x3C)==0x5A534A00&&CPU[tgt]>=0x0A76A0)
                        {
                            if(add>0&&CPU[tgt]>=0x800000)
                            {
                                CPU[tgt]+=add;
                            }
                            else
                            {
                                CPU[tgt]+=0xAB7960;
                            }
                        }
                        else
                        {
                            if(CPU[tgt]>=pc&&CPU[tgt]<=end-4)
                            {
                                CPU[tgt]-=pc;
                                CPU[tgt]+=base[mode];
                            }
                            else
                            {
                                goto label;
                            }
                        }
                        for(sum=0;sum<4;sum+=1)
                        {
                            if(RAM[CPU[tgt]+sum]<0x0A||RAM[CPU[tgt]+sum]>0x7E)
                            {
                                break;
                            }
                        }
                        if(sum==4)
                        {
                            printf("%s = \"",names[tgt]);
                            while(sum!=0)
                            {
                                sum=RAM[CPU[tgt]+ext];
                                ext+=1;
                                if(sum==0){break;}
                                printf("%c",sum);
                            }
                            printf("\"\n");
                        }
                        if(read32(RAM,0x3C)==0x242C343C&&CPU[tgt]>=0x128F50)
                        {
                            if(read32(RAM,0x738C8)==0x25085690)
                            {
                                CPU[tgt]+=0x3E70B0;
                            }
                            else
                            {
                                CPU[tgt]-=base[mode];
                                CPU[tgt]+=pc;
                            }
                        }
                        else if(read32(RAM,0x3C)==0x41464A00&&CPU[tgt]>=0x675720)
                        {
                            CPU[tgt]-=0x623CA0;
                        }
                        else if(read32(RAM,0x3C)==0x534D4A00&&CPU[tgt]>=0xF4210)
                        {
                            CPU[tgt]+=0x2845F0;
                        }
                        else if(read32(RAM,0x3C)==0x5A4C450F&&CPU[tgt]>=0xA94000)
                        {
                            if(CPU[tgt]>=ovl_b&&CPU[tgt]<ovl_e)
                            {
                                CPU[tgt]-=add;
                            }
                            else
                            {
                                CPU[tgt]-=0xA771A0;
                            }
                        }
                        else if(read32(RAM,0x3C)==0x5A4C4A00&&CPU[tgt]>=0xA87000)
                        {
                            CPU[tgt]-=0xA75F60;
                        }
                        else if(read32(RAM,0x3C)==0x5A534A00&&CPU[tgt]>=0xB5F000)
                        {
                            if(CPU[tgt]>=ovl_b&&CPU[tgt]<ovl_e)
                            {
                                CPU[tgt]-=add;
                            }
                            else
                            {
                                CPU[tgt]-=0xAB7960;
                            }
                        }
                        else
                        {
                            CPU[tgt]-=base[mode];
                            CPU[tgt]+=pc;
                        }
                        label:
                        CPU[tgt]|=0x80000000;
                    }
                    if(ext==0)
                    {
                        if(tgt<T0)
                        {
                            if((CPU[tgt]&0xffffff)>=(ovl_b-add)&&(CPU[tgt]&0xffffff)<(ovl_e-add))
                            {
                                CPU[tgt]&=0xffffff;
                                for(loop=0;loop<num;loop+=1)
                                {
                                    if(addr_db[loop]==CPU[tgt]+add)
                                    {
                                        printf("%s = %s\n",names[tgt],symb_db[loop]);
                                        break;
                                    }
                                }
                                if(loop==num){CPU[tgt]|=0x80000000;printf("%s = 0x%X\n",names[tgt],CPU[tgt]);}
                            }
                            else{printf("%s = 0x%X\n",names[tgt],CPU[tgt]);}
                        }
                        else
                        {
                            for(loop=0;loop<num;loop+=1)
                            {
                                if(add==0){break;}
                                if(addr_db[loop]==(CPU[tgt]&0x1FFFFFFF)+add)
                                {
                                    CPU[tgt]=loop; //new
                                    for(ext=addr+1;ext<(func_end/4);ext+=1)
                                    {
                                        if(op(read32(RAM,func+ext*4))>=40&&rt(read32(RAM,func+ext*4))==tgt)
                                        {
                                            if(rs(read32(RAM,func+ext*4))==SP)
                                            {
                                                printf("%s = %s\n",names[tgt],symb_db[loop]);
                                            }
                                            else
                                            {
                                                printf("%08X\n",inst);
                                            }
                                            break;
                                        }
                                    }
                                    break;
                                }
                            }
                            if(loop==num||loop==0||ext==(func_end/4)){printf("%08X\n",inst);}
                            ext=0;
                        }
                    }
                }
                if(rs(inst)==R0&&rt(inst)==A0)
                {
                for(loop=addr+1;loop<(func_end/4);loop+=1)
                {
                    if(rs(inst)==R0&&rt(inst)==A0)
                    {
                    if(read32(RAM,func+loop*4)==0x00801025)
                    {
                        message_set(RAM,CPU[A0]);
                    }
                    }
                    else{break;}
                }
                }
                if((func+addr*4)==addiu_jump[0]||(func+addr*4)==(addiu_jump[0]+4))
                {
                    addiu_jump[0]=4;
                }
                break;
            case ANDI:
                tgt=rt(inst);
                CPU[tgt]=CPU[rs(inst)]&imm(inst);
                printf("%s = 0x%x\n",names[tgt],CPU[tgt]);
                break;
            case ORI:
                tgt=rt(inst);
                CPU[tgt]=CPU[rs(inst)]|imm(inst);
                for(loop=0;loop<num;loop+=1)
                {
                    if(addr_db[loop]==CPU[tgt]&&CPU[tgt]>0xFFF)
                    {
                        printf("%s = %s\n",names[tgt],symb_db[loop]);
                        break;
                    }
                }
                if(loop==num)
                {
                    printf("%08X\n",inst);
                }
                break;
            case LUI:
                if(LUIWATCH[rt(inst)]==1){LUIWATCH[rt(inst)]=0;}
                tgt=imm(inst);
                CPU[rt(inst)]=tgt<<16;
                for(loop=0;loop<num;loop+=1)
                {
                    if(addr_db[loop]==tgt>>8)
                    {
                        for(tgt=addr+1;tgt<(func_end/4);tgt+=1)
                        {
                            if(op(read32(RAM,func+tgt*4))==SW&&rt(read32(RAM,func+tgt*4))==rt(inst)&&imm(read32(RAM,func+tgt*4))==0)
                            {
                                if(op(read32(RAM,func+tgt*4+8))==SW)
                                {
                                    if(rt(read32(RAM,func+tgt*4+8))!=rt(inst))
                                    {
                                        LUIWATCH[rt(inst)]=1;
                                    }
                                    else if(rt(read32(RAM,func+tgt*4+8))==rt(inst))
                                    {
                                        if((imm(read32(RAM,func+tgt*4+8))&0xF)==0)
                                        {
                                            LUIWATCH[rt(inst)]=1;
                                        }
                                    }
                                }
                                else if(op(read32(RAM,func+tgt*4+8))!=SW)
                                {
                                    LUIWATCH[rt(inst)]=1;
                                }
                                break;
                            }
                        }
                        break;
                    }
                }
                if(op(read32(RAM,func+(addr+1)*4))>=BEQ&&op(read32(RAM,func+(addr+1)*4))<ADDI)
                {
                    addiu_jump[0]=extend(imm(read32(RAM,func+(addr+1)*4))<<2)+func+addr*4+8;
                    addiu_jump[1]=CPU[rt(inst)];
                }
                break;
            case BNEL:
                tgt=func+addr*4+4;
                RAM[tgt]=0;
                RAM[tgt+1]=0;
                RAM[tgt+2]=0;
                RAM[tgt+3]=0;
                printf("%08X\n",inst);
                break;
            case LB:
                tgt=rt(inst);
                CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
                for(loop=0;loop<num;loop+=1)
                {
                    if(addr_db[loop]==CPU[tgt]&&CPU[tgt]>0xFFF)
                    {
                        printf("%s = %s\n",names[tgt],symb_db[loop]);
                        break;
                    }
                }
                if(loop==num)
                {
                    printf("%08X\n",inst);
                }
                break;
            case LW:
                tgt=rt(inst);
                CPU[tgt]=CPU[rs(inst)]+extend(imm(inst));
                if(rs(inst)==SP)
                {
                    printf("%s = sp%x\n",names[tgt],extend(imm(inst)));
                }
                else
                {
                    for(loop=0;loop<num;loop+=1)
                    {
                        if(addr_db[loop]==CPU[tgt]&&CPU[tgt]>0xFFF)
                        {
                            printf("%s = %s\n",names[tgt],symb_db[loop]);
                            break;
                        }
                    }
                    if(loop==num)
                    {
                        printf("%08X\n",inst);
                    }
                }
                break;
            case LH:
            case LHU:
                tgt=CPU[rs(inst)]+extend(imm(inst));
                if(rs(inst)>=A0&&rs(inst)<T0&&tgt>=(regs|0x80000000)&&ovl_b>4)
                {
                    if(func>=ovl_b&&func<ovl_e)
                    {
                    tgt&=0x1fffffff;
                    tgt-=regs;
                    if(tgt<=0x3FFFE){CPU[rt(inst)]=(REG[tgt]<<8)|REG[tgt+1];}
                    for(loop=0;loop<num;loop+=1)
                    {
                        if(addr_db[loop]==((tgt+regs)|0x80000000))
                        {
                            printf("%s = %s",names[rt(inst)],symb_db[loop]);
                            break;
                        }
                    }
                    if(loop==num)
                    {
                        printf("%s = 0x%X",names[rt(inst)],((tgt+regs)|0x80000000));
                    }
                    }
                }
                if(add>0)
                {
                    switch(imm(inst))
                    {
                        case 0x10E:
                        case 0x2C4:
                            if(read32(RAM,0x3C)==0x5A4C450F)
                            {
                                if(rt(inst)!=A1){CPU[rt(inst)]=0x10E;}
                            }
                            if(read32(RAM,0x3C)==0x5A534A00)
                            {
                                if(rt(inst)!=A1){CPU[rt(inst)]=0x2C4;}
                            }
                    }
                }
                //if(add>0&&imm(inst)==0x10E)
                //{
                //    if(rt(inst)!=A1){CPU[rt(inst)]=0x10E;}
                //}
                if(op(inst)==LH||op(inst)==LHU)
                {
                    if(tgt>=((ovl_b-add)|0x80000000)&&ovl_b>4)
                    {
                        if(func>=ovl_b&&func<ovl_e&&tgt<(regs|0x80000000))
                        {
                            tgt&=0x1fffffff;
                            tgt+=add;
                            if(tgt<(end-1))
                            {
                                CPU[rt(inst)]=((RAM[tgt]<<8)|RAM[tgt+1]);
                                if(op(inst)==LH)
                                {
                                    CPU[rt(inst)]=extend((unsigned short)(CPU[rt(inst)]));
                                }
                            }
                        }
                    }
                }
                printf("\n");
                break;
            case SB:
            case SH:
            case SW:
                tgt=CPU[rs(inst)]+extend(imm(inst));
                if(LUIWATCH[rt(inst)]==1){goto gfx;}
                for(loop=0;loop<num;loop+=1)
                {
                    if(addr_db[loop]==tgt&&tgt>0xFFF)
                    {
                        printf("%s = %s",symb_db[loop],names[rt(inst)]);
                        break;
                    }
                }
                goto exit;
                gfx:
                for(loop=0;loop<num;loop+=1)
                {
                    if(addr_db[loop]==CPU[rt(inst)]>>24&&imm(inst)==0)
                    {
                        printf("%08X //",inst);
                        decompile_gfx(addr_db,addr_db[loop],num,CPU[rt(inst)]&0xFFFFFF);
                        printf(" (%02X %06X)",addr_db[loop],CPU[rt(inst)]&0xFFFFFF);
                        break;
                    }
                }
                exit:
                if(loop==num)
                {
                loop=0;
                if(rt(inst)>=T0&&rt(inst)<K0&&add>0)
                {
                    for(loop=0;loop<num;loop+=1)
                    {
                        if(addr_db[loop]==imm(inst)&&addr_db[loop]>0xFF)
                        {
                            if(CPU[rt(inst)]<num)
                            {
                                printf("%s = %s",symb_db[loop],symb_db[CPU[rt(inst)]]);//names[rt(inst)]);
                            }
                            else
                            {
                                printf("%s = 0x%X //add = %X",symb_db[loop],CPU[rt(inst)],add);
                            }
                            break;
                        }
                    }
                }
                if(loop==0||loop==num){printf("%08X",inst);}
                }
                printf("\n");
                if(imm(inst)==0x10E||imm(inst)==0x2C4){CPU[A1]=CPU[rt(inst)];}
                if(imm(inst)==0x116&&op(inst)==SH&&rt(inst)!=V0)
                {
                    message_set(DEMO,CPU[rt(inst)]);
                }
                break;
            default:
                if(inst!=0)
                {
                    printf("%08X\n",inst);
                }
                break;
        }
        if(op(read32(RAM,func+addr*4+4))==JAL)
        {
            printf("\n");
        }
        if(op(read32(RAM,func+addr*4-4))==JAL)
        {
            printf("\n\n");
        }
        if(((inst>>16)&0xFFF)==0x441)
        {
            if(CPU[rs(inst)]==0x10E)
            {
                message_set(RAM,CPU[AT]);
            }
        }
    }
    choose:
    func_end=0;
    if(ovl_funcs[ovl_tracker]==0)
    {
    system("pause");
    printf("Go again? (y/n) ");
    scanf("%s",choice);
    if(choice[0]==0x79){goto again;}
    }
    else
    {
    goto again;
    }
    free(RAM);
    free(REG);
    free(DEMO);
    return 0;
}