Nintendo Ingrish

Following lines were found in Nintendo DS SDK.

        // If the 8th bit of the data length storage byte is 0, it not an encoding data sequence.
    u4  RLDstCount;    // Expansion data size in bytes

    u4  RLSrcCount;    // Size of data that is targeted for expansion in bytes--after processing
        if ( srcp[ RLSrcCount ] & 0x80 )    // decoding process (run length encoded)

        {

            length = srcp[ RLSrcCount++ ] & 0x7f; // store data length (three geta are worn, so consider it actually +3)
// Data expansion control function (Because it auto expands, it will not run if at the end there is no header for raw data expansion.)
    u8  *startp;        // Points to the beginning of data that is the compression target for one process loop.
    pCompList = compList;       // Points to the array that holds the compression sequence.
    // Process to add a NULL header (pseudo header for data before it is compressed)
            tmp =  srcp[i] & 0x0f;          HuffTable[tmp].Freq++;  // The concern is the encoding floor

            // search target data must be data from before two byte.

            //

            // offset is stored as 12-bit so less than 4096

u4

Ever read code written by French people? It's much worse than that.

Did they have problems withthe keeping standard tab indent?

>>2
see ntrcomp/nitroCompLib.c

>>3
Worse than "Process to add a NULL header"?

>>5
Post it

/*---------------------------------------------------------------------------*

  Project:  NitroSDK - tools - nitroCompLib

  File:     nitroCompLib.c



  Copyright 2003,2004 Nintendo.  All rights reserved.



  These coded instructions, statements, and computer programs contain

  proprietary information of Nintendo of America Inc. and/or Nintendo

  Company Ltd., and are protected by Federal copyright law.  They may

  not be disclosed to third parties or copied or duplicated in any form,

  in whole or in part, without the prior written consent of Nintendo.



  $Log: nitroCompLib.c,v $

  Revision 1.7  2004/10/08 04:31:52  takano_makoto

  Fixed bug in debug extraction routine.



  $NoKeywords: $

 *---------------------------------------------------------------------------*/



#include "nitroCompLib.h"



#undef _DEBUG

#ifdef _DEBUG

#define new DEBUG_NEW

#define DEBUG_PRINT

// #define DEBUG_PRINT_DIFFFILT

#define DEBUG_PRINT_RL

// #define DEBUG_PRINT_HUFF

// #define DEBUG_PRINT_LZ

// #define DEBUG_PRINT_DATAMATCH

#endif





#ifdef __cplusplus

#define EXTERN extern "C"

#define STATIC

#else

#define EXTERN

#define STATIC static

#endif





#ifdef DEBUG_PRINT

#define dbg_printf fprintf

#else

#define dbg_printf dummy

#endif



#ifdef DEBUG_PRINT_DIFFFILT

#define dbg_printf_dif fprintf

#else

#define dbg_printf_dif dummy

#endif



#ifdef DEBUG_PRINT_RL

#define dbg_printf_rl fprintf

#else

#define dbg_printf_rl dummy

#endif



#ifdef DEBGU_PRINT_HUFF

#define dbg_printf_huff fprintf

#else

#define dbg_printf_huff dummy

#endif



#ifdef DEBGU_PRINT_LZ

#define dbg_printf_lz fprintf

#else

#define dbg_printf_lz dummy

#endif



#ifdef DEBUG_PRINT_DATAMATCH

#define dbg_printf_match fprintf

#else

#define dbg_printf_match dummy

#endif



void dummy(void *fp, ...) {}



#define DIFF_CODE_HEADER        (0x80)

#define RL_CODE_HEADER          (0x30)

#define LZ_CODE_HEADER          (0x10)

#define HUFF_CODE_HEADER        (0x20)

#define CODE_HEADER_MASK        (0xF0)







//==================================================================================

// Global Variable Declaration

//==================================================================================

static  u8      *pCompBuf[ 2 ];       // double buffer used during compression process

static  u8       compBufNo = 1;     // shows available double buffer

static  char    *pCompList;         // compList current reference point



//==================================================================================

// Prototype declaration

//==================================================================================

STATIC u32      RawWrite(       u8 *srcp, u32 size, u8 *dstp);

STATIC u32      DiffFiltWrite(  u8 *srcp, u32 size, u8 *dstp, u8 diffBitSize);

STATIC u32      RLCompWrite(    u8 *srcp, u32 size, u8 *dstp);

STATIC u32      LZCompWrite(    u8 *srcp, u32 size, u8 *dstp, u8 lzSearchOffset);

STATIC u32      HuffCompWrite(  u8 *srcp, u32 size, u8 *dstp, u8 huffBitSize);



STATIC s32      RawRead(        u8 *srcp, u32 size, u8 *dstp);

STATIC s32      DiffFiltRead(   u8 *srcp, u32 size, u8 *dstp, u8 diffBitSize);

STATIC s32      RLCompRead(     u8 *srcp, u32 size, u8 *dstp);

STATIC s32      LZCompRead(     u8 *srcp, u32 size, u8 *dstp);

STATIC s32      HuffCompRead(   u8 *srcp, u32 size, u8 *dstp, u8 huffBitSize);



/*

//==================================================================================

// Functions for DLL

//==================================================================================

EXTERN BOOL WINAPI DllMain( HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved)

{

    return TRUE;

}

*/



//----------------------------------------------------------------------------------

//  Secures memory region for putting data after compression

//    Secures an area twice the size of data before compression

//----------------------------------------------------------------------------------

EXTERN u8 * __stdcall nitroCompMalloc(u32 size)

{

    return (u8 *)malloc( size * 3 + 512 );

}



//----------------------------------------------------------------------------------

//  Releases the memory area where the data was placed after compression

//----------------------------------------------------------------------------------

EXTERN void __stdcall nitroCompFree(u8 *p)

{

    if ( p != NULL ) {

        free( (void *)p );

        p = NULL;

    }

}



//------------------------------------------------------------

//  Data compression

//------------------------------------------------------------

EXTERN u32  __stdcall nitroCompress(u8 *srcp, u32 size, u8 *dstp, char *compList, u8 rawHeaderFlag)

{

    u32      dataSize, nextDataSize;    // Compression data size (bytes)

    u8      *pReadBuf;                  // Pointer that indicates the first address of the compression data.

    u8       bitSize;                   // Unit suitable for difference filter, Huffman encoding.

    char     str[16];

    u16      i,j;

    u8       lzSearchOffset;



//  pCompBuf[0] = (u8 *)malloc(size*2 + 4 + 256*2);     // Because the worst Huffman size is size*2 + 4 + 256*2,

//  pCompBuf[1] = (u8 *)malloc(size*2 + 4 + 256*2);     // other compression or adding a data header could make                                            this insufficient.

    pCompBuf[0] = (u8 *)malloc( size * 3 + 256 * 2 );    

    pCompBuf[1] = (u8 *)malloc( size * 3 + 256 * 2 );

    pReadBuf    = pCompBuf[0];

    compBufNo   = 1;                // Important!! If you do not do this, you will have problems the second time you call nitroCompress.



    // malloc check

    if ( pCompBuf[0] == NULL || pCompBuf[1] == NULL ) {

        fprintf(stderr, "Error: Memory is not enough.\n");

        exit(1);

    }



    dataSize = size;



    // Process to add a NULL header (pseudo header for data before it is compressed)

    if ( rawHeaderFlag )  {

        dataSize        += 4;

        *(u32 *)pReadBuf =  size << 8 | 0;  // Data header

        memcpy( &pReadBuf[4], srcp, size );

    } else {

        memcpy( pReadBuf, srcp, size );

    }



    pCompList = compList;       // Points to the array that holds the compression sequence.



    // Loop while there are elements in the array that holds the compression sequence.

    while (1) {

        switch (*pCompList) {

        case 'd': 

            {

                pCompList++;            // 8 or 16 comes after 'd'

                str[0] = *pCompList;

                if (*pCompList == '1') {

                    pCompList++;

                    str[1] = *pCompList;

                    str[2] = '\n';

                }

                bitSize = atoi(str);    // Stores in units that are suitable for the difference filter.

                str[0] = str[1] = '\n';

                       

                dbg_printf(stderr,"nitroCompress  Diff %d\n",bitSize);

                       

                if ((bitSize == 16) && (dataSize & 0x01)) {

                    fprintf(stderr, "16-bit differencial filter must be 2-byte allignment.\n");

                    exit(1);

                }

                nextDataSize = DiffFiltWrite(  pReadBuf,dataSize,pCompBuf[compBufNo],bitSize);

            }

            break;



        case 'r':  

            {

                dbg_printf( stderr,"nitroCompress  RL\n" );

                       

                nextDataSize = RLCompWrite( pReadBuf, dataSize, pCompBuf[ compBufNo ] );

            }

            break;



        case 'l':  

            {

                pCompList++;

                i = 0;

                while ( isdigit(*pCompList) ) {

                    str[i] = *pCompList;

                    pCompList++;

                    i++;

                    if ( i == 15 ) {

                        break;

                    }

                }

                str[i] = '\n';

                pCompList--;

                lzSearchOffset = (u8)atoi(str);   // Truncate to round large values.

                for ( j = 0; j < i; j++ ) {

                    str[j] = '\n';

                }

                dbg_printf( stderr, "nitroCompress  L %d\n", lzSearchOffset );



                nextDataSize = LZCompWrite( pReadBuf, dataSize, pCompBuf[compBufNo], lzSearchOffset );

            }

            break;



        case 'h':

            {

                pCompList++;            // 4 or 8 comes after 'h'

                str[0]  = *pCompList;

                str[1]  = '\n';

                bitSize = atoi(str);    // 4 or 8

                str[0] = '\n';



                dbg_printf( stderr, "nitroCompress  Huff %d\n", bitSize );



                nextDataSize = HuffCompWrite( pReadBuf, dataSize, pCompBuf[compBufNo], bitSize );

            }

            break;

        //-----------------------------------------

        // Compression end  (*CompTypeBufp is NULL)

        default:   

            {

                dbg_printf( stderr, "nitroCompress  raw\n" );



                RawWrite(pReadBuf, dataSize, dstp);

                if ( pCompBuf[0] != NULL ) {

                    free( (void *)pCompBuf[0] );

                    pCompBuf[0] = NULL;

                }

                if (pCompBuf[1] != NULL) {

                    free( pCompBuf[1] );

                    pCompBuf[1] = NULL;

                }

                return dataSize;

   

            }

        }

        // One more loop

        pReadBuf    =   pCompBuf[ compBufNo ];

        compBufNo   ^=  0x01;

        dataSize    =   nextDataSize;

        pCompList++;

    }

}





//===========================================================================

//  Copy compression data

//===========================================================================

STATIC u32 RawWrite(u8 *srcp, u32 size, u8 *dstp)

{

    u32 i;



    dbg_printf( stderr, "RawWrite\tsize=%d\n\n",size );



    for ( i = 0; i < size - 1; i++ ) {

        *dstp = *srcp;

        dstp++;

        srcp++;

    }

    *dstp = *srcp;



    return size;

}





//===========================================================================

//  Difference filter

//===========================================================================

STATIC u32 DiffFiltWrite( u8 *srcp, u32 size, u8 *dstp, u8 diffBitSize )

{

    u32  DiffCount;     // Compression data size in bytes

    u32  i;



    u16 *src16p = (u16 *)srcp;

    u16 *dst16p = (u16 *)dstp;



    dbg_printf_dif( stderr, "DiffFiltWrite\tsize=%d\tdiffBitSize=%d\n", size, diffBitSize );



    *(u32 *)dstp = size << 8 | ( DIFF_CODE_HEADER | diffBitSize / 8 );    // data header



    DiffCount = 4;



    if (diffBitSize == 8)

    {

#ifdef DEBUG_PRINT_DIFFFILT

        for ( i = 0; i < 16; i++ ) {

            dbg_printf_dif(stderr, "srcp[%d] = %x\n",i,srcp[i]);

        }

#endif

        dstp[DiffCount] = srcp[0];                  // top table only without diffs

        DiffCount++;

        for ( i = 1; i < size; i++, DiffCount++ )

        {

            dbg_printf_dif( stderr, "dstp[%x] = srcp[%d]-srcp[%d] = %x - %x = %x\n",

                            DiffCount, i, i - 1, srcp[i], srcp[i-1], srcp[i] - srcp[i-1] );

           

            dstp[DiffCount]     = srcp[i] - srcp[ i - 1 ];  // diff data storage

        }

    }

    else // 16-bit size

    {

        dst16p[DiffCount/2] = src16p[0];

        DiffCount += 2;

        for ( i = 1; i < size / 2; i++, DiffCount += 2 ) {

            dst16p[DiffCount/2] = src16p[i] - src16p[i-1]; 

        }

    }



    // 4-byte border alignment

    //    0 data for alignment is not included in the data size.

    i = 0;

    while ((DiffCount+i) & 0x3) {

        dstp[DiffCount+i] = 0;

        i++;

    }



    return DiffCount;

}





//===========================================================================

//  Run length encoding (bytes)

//===========================================================================

STATIC u32 RLCompWrite      (u8 *srcp, u32 size, u8 *dstp)

{  

    u32  RLDstCount;    // Compression data size in bytes

    u32  RLSrcCount;    // Size of data that is the targeted for compression, after processing is complete (bytes)

    u8   RLCompFlag;    // For run length encoding use 1

    u8   runLength;     // Run length

    u8   rawDataLength; // Length of data that is not run

    u32  i;



    u8  *startp;        // Points to the beginning of data that is the compression target for one process loop.

   

    dbg_printf_rl( stderr, "RLCompWrite\tsize=%d\n", size );



    //  data header       (size is after extraction)

    *(u32 *)dstp    = size << 8 | RL_CODE_HEADER;     // data header

    RLDstCount      = 4;



    RLSrcCount      = 0;

    rawDataLength   = 0;

    RLCompFlag      = 0;

   

    while ( RLSrcCount < size )

    {

        startp = &srcp[ RLSrcCount ]; // Setting the compression target data

       

        for ( i = 0; i < 128; i++ )   // Data sized 0-127 can be expressed as 7-bit

        {

            // Reached the end of the compression target data.

            if ( RLSrcCount + rawDataLength >= size ) {

                rawDataLength = (u8)(size - RLSrcCount);

                break;

            }

           

            if ( RLSrcCount + rawDataLength + 2 < size ) {

                if ( startp[ i ] == startp[ i + 1 ] &&

                     startp[i] == startp[i+2] )

                {

                    RLCompFlag = 1;

                    break;

                }

            }

            rawDataLength++;

        }



        // Store data that will not be encoded.

        // If the 8th bit of the data length storage byte is 0, it not an encoding data sequence.

        // Data length is the number -1. Therefore 0-127 becomes 1-128.

        if ( rawDataLength ) {

            dstp[ RLDstCount++ ] = rawDataLength - 1;     // "Data length -1" storage (7 bits)

            for ( i = 0; i < rawDataLength; i++ ) {

                dstp[ RLDstCount++ ] = srcp[ RLSrcCount++ ];

            }

            rawDataLength = 0;

        }



        // Run length encoding

        if ( RLCompFlag )

        {

            runLength = 3;

            for ( i = 3; i < 128 + 2; i++ ) {

                // Reached the end of the data for compression

                if ( RLSrcCount + runLength >= size ) {

                    runLength = (u8)( size - RLSrcCount );

                    break;

                }

               

                // If there is a pause in the run

                if ( srcp[ RLSrcCount ] != srcp[ RLSrcCount + runLength ] ) {

                    break;

                }

                // Continuing the run

                runLength++;

            }



            // If the 8th bit of the data length storage byte is 1, it is an encoded data sequence.

            dstp[ RLDstCount++ ] = 0x80 | ( runLength - 3 );  // Add 3 from the bottom and store 3-130

            dstp[ RLDstCount++ ] = srcp[ RLSrcCount ];

            RLSrcCount          += runLength;

            RLCompFlag           = 0;

        }

    }

       

    // 4-byte border alignment

    //   0 data for alignment is not included in the data size

    i = 0;

    while ( ( RLDstCount+i ) & 0x3 ) {

        dstp[RLDstCount+i] = 0;

        i++;

    }



    return RLDstCount;

}

//===========================================================================

//  LZ77 compression

//===========================================================================

STATIC u32 LZCompWrite( u8 *srcp, u32 size, u8 *dstp, u8 lzSearchOffset )

{

    u32  LZDstCount;    // Compression data size in bytes

    u32  LZSrcCount;    // Size of data that is the target of compression, after processing is complete (bytes)

    u8   LZCompFlags;   // Flag sequence that indicates whether compression or not.

    u8  *LZCompFlagsp;  // Points to the memory region that stores LZCompFlags

    u8  *compressingDataHeadp;  // Beginning address of the current data region that is targeted for compression.

    u8  *searchp;       // Beginning address of the matching data search region

    u16  tmpOffset;     // Offset to the matching data (mid-search data)

    u8   tmpLength;     // Matching data length (mid-search data)

    u16  lastOffset;    // Offset to matching data (longest matching data at that time)

    u8   lastLength;    // Matching data length (longest matching data at that time)

    u8   i;



    dbg_printf_lz( stderr, "LZCompWrite\tsize=%d\tlzSearchOffset=%d\n", size, lzSearchOffset );



    *(u32 *)dstp = size << 8 | LZ_CODE_HEADER;                 // data header

    LZDstCount   = 4;

   

    LZSrcCount = 0;

    while ( LZSrcCount < size )

    {

        LZCompFlags     = 0;

        LZCompFlagsp    = &dstp[ LZDstCount++ ];          // storage target of flag series

   

        // flag series is stored as 8-bit data, so 8-time loop

        for ( i = 0; i < 8; i++ )

        {

            LZCompFlags <<= 1;  // the first time (i=0) carries no special significance

            lastOffset  = 0;

            lastLength  = 0;

            compressingDataHeadp = &srcp[ LZSrcCount ];



            // VRAM is two-byte access so (since there are cases where data is read from VRAM)

            // search target data must be data from before two byte.

            //

            // offset is stored as 12-bit so less than 4096

            for ( tmpOffset = lzSearchOffset; tmpOffset <= LZSrcCount && tmpOffset <= 4096; tmpOffset++ )

            {

                if ( LZSrcCount >= size ) {

                    break;

                }

                searchp = &srcp[ LZSrcCount - tmpOffset ];    // search data region setting

                if (*searchp == *compressingDataHeadp)      // matching data found

                {

                    // data length is stored with four bits, so less than 18 (put on the 3 clog)

                    for ( tmpLength = 1; tmpLength <= 16 + 2; tmpLength++ ) {

                        if ( searchp[ tmpLength ] != compressingDataHeadp[ tmpLength ] ) {

                            break;

                        }

                    }

                    if ( tmpLength > 16 + 2 ) {

                        tmpLength = 18; // so it doesn't become 19

                    }

                    if ( LZSrcCount + tmpLength >= size ) {

                        tmpLength = (u8)(size - LZSrcCount);

                    }

                    // update the longest matching data

                    if ( tmpLength >= 3 && tmpLength > lastLength ) {

                        lastOffset   = tmpOffset;

                        lastLength   = tmpLength;

                        LZCompFlags |= 0x01;

                    }

                }

            }

            // storage of LZCompFlags one compressed data

            if ( LZSrcCount < size ) {

                if ( (LZCompFlags & 0x01) == 0 ) {  // no compression

                    dstp[ LZDstCount++ ]  = srcp[ LZSrcCount++ ];

                } else {

                    // offset is separated into top four bits and bottom eight bits and stored

                    dstp[ LZDstCount++ ]   = (lastLength - 3) << 4 | (lastOffset - 1) >> 8;

                    dstp[ LZDstCount++ ]   = (lastOffset - 1) & 0xff;

                    LZSrcCount          += lastLength;

                }

            }

        }   // 8-time loop ends

        *LZCompFlagsp   = LZCompFlags;                  // store flag series

    }



    // four byte boundary alignment

    //   don't include data 0 for alignment in data size

    i = 0;

    while ( (LZDstCount + i) & 0x3 ) {

        dstp[ LZDstCount + i ] = 0;

        i++;

    }



    return LZDstCount;

}

A fatal error occured!
Thanks for your contribution, but it was too large.

>>9,10
What are u8 and its likes? Did FV write that code?

>>12
"takano_makoto"

>>13
What?

>>14
nintendo programmer, who worked on n64, nds and wii.

>>15
Is that FV's real name?

>>12
8 bit unsigned

u4,u8,u16

Apparently they have a 4bit unsigned type

Excuse my autism but numbers should be power of 2 bits, like this:
u0=0bit
u1=1bit
u2=2bits
u3=4bits
u4=8bits
u5=16bits
u6=32bits
u7=64bits
u8=128bits

>>18
That looks retarded.

RANDUM.LIB:
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
; Get Randum number
RAND:
    ;randun number set routne

    ;ret    A : ramdun number
    ;dest   AF

    PUSH    HL
    LD  HL,(RANNUM)
    LD  A,H
    RRCA
    RRCA
    XOR H
    RRCA
    XOR L

    do  4
    RRCA
    loop

    XOR L
    RRCA
    ADC HL,HL
    JR  NZ,$+5

    LD  HL,733CH
    LD  A,R
    XOR L
    LD  (RANNUM),HL
    POP HL
    RET

;end

http://www.romhacking.net/?page=documents&category=13
http://www.romhacking.net/documents/605/

>>18
LOL. I've seen u0 used as void.

>>18
u0=0bit
I don't think you understand how exponentiation works. Back to /faggot/, fuckhead.

>>22
Proof or GTFO!

>>23
https://en.wikipedia.org/wiki/Exponentiation#Zero_exponent

>>24
GTFO!

>>18'
>2^0 = 0

good one

>>25
NO U!

>>18
Every 'power' > 0 is actually fucking wrong. 2^3 = 4

IHBT

>>28,22-21,26,19
YHBT

>>28
Looks pretty logical to me and fits every usage case.
My current systems doesn't handle bit quantities as is based on sizeof(x) which counts in chars
u1=1,u2=2,u4=4,u8=8.I'll use >>18 instead.

>>29
FUCK YOU, FAGGOT

>>30
You're retarded frozen, im sure that system works perfectly for you

dubs

Can you upload the official DS SDK somewhere, OP? I'd be very interested in researching such a thing.

>>34
Why do you use `OP' instead of `>>1'? Why do you ask someone to step into illegality?
Are you some kind of evil-doer?

>>35
Yes.

>>34
Try p2p networks.

love chinese english!

  v22 = fopen_(v5, "rb");
  if ( !v22 )
    sub_10034("No can open file");
  fread_((char *)&dword_97884 + 2, 794, 1, v22);
  if ( dword_97884 >> 16 != 'x' || *(int *)((char *)&dword_97884 + 2) >> 16 != 'u' || dword_97888 >> 16 != 'b' )
    sub_10034("no xub file");
  if ( v29 > dword_9788C )
    sub_10034("error");
  v23 = nmalloc_((*(int *)((char *)&dword_97892 + 2) >> 16) * 2 * (dword_97892 >> 16));
  if ( !v23 )
    sub_10034("Need mem");

>>35
These days I'm not as active on textboards as I used to be, otherwise I might have remembered to call him ``>>1-san'' instead.
I understand that uploading the SDK would be illegal, but I assumed that if he were willing to discuss and paste snippets from the SDK, he might have acquired it illegally himself, in which case he might be willing to direct others to it. He might also be a licensed developer who is willing to discuss the SDK while taking reasonable measures to cover his tracks (using an encrypted proxy, connecting to public wifi in a restaurant whose services have been paid for in cash, etc), yet does not want to deal with all the troubles that being responsible for an actual leak would cause.

Regardless of which is true, I would be completely understanding if he were to decline to upload it. I had to ask anyways, just in case he was willing to, since I wasn't aware of any leaks of the SDK.

>>38
BTW, they do really check for malloc return! That is what I call retarded: if malloc returns 0, it's as good as crashed anyway.

>>40
Really?

>>41
Because C++ has no garbage collection.

mikology

check 'em

>>40
if malloc returns 0, it's as good as crashed anyway.
Cowardly lies.

Next you're going to tell me you can't have any more than 128 sprites on-screen.

>>45
Did you mean: 256 sprites on a scanline?

>>18
power of 2 bits
But I'm using a PDP-10. What now, faggot?

>>46
NES had stricter limit.

>>46
No, I meant something obviously false, like >>40's statement.

>>49
So, what do you do, when malloc tells you to fuck off?

>>50
Halt and catch fire.

>>51
malloc does that for you.

>>50
It really depends on the situation. Blender waits and tries again. Doom prints an error (and perhaps could have even recovered automatically.) Small-console games may be able to recover by doing less, but they would more likely be designed to work within the memory limits with no possibility of overusing it. Memory pack enabled systems can fail over to the external (slower) memory.

>>50

flush the caches!

dump for weeboo rage