/*	This file was automatically created by
 *	Reverse Engineering Compiler 1.4a (C) Giampiero Caprino (Nov 22 1998)
 *	Input file: 'hdg.x'
 */

/*	Procedure: 0x00040074 - 0x000402C3
 *	Argument size: -116
 *	Local size: 128
 *	Save regs size: 0
 */

dumpline(unsigned char * p, unsigned long  offset, int cnt)
{
	char  buff[80];
	int c;
	int len;



    V8 = r3;
    Vc = r4;
    V10 = r5;
    sprintf( & buff, "%08lX:", Vc);
    if(V10 > 16) {
        V10 = 16;
    }
    c = 0;
    while(c < V10) {
        r9 = c;
        r10 = r9;
        asm("rlwinm	r11,r10,1,0,30");
        r0 = & buff + r11 + r9 + 9;
        r9 = V8 + c;
        r11 = *r9;
        asm("clrlwi	r9,r11,24");
        r11 = 262144;
        sprintf(r0, " %02lX", r9);
        c = c + 1;
    }
    while(1) {
        r9 = & c;
        r0 = *r9;
        r11 = r0;
        *r9 = r0 + 1;
        if(r11 > 15) {
            break;
        }
        strcat( & buff, " ");
    }
    len = strlen( & buff);
    strcpy( & buff + len, " |");
    c = 0;
    while(c < V10) {
        r9 = & V8 + len + c;
        r0 = V8;
        r10 = *(r0 + c);
        asm("clrlwi	r0,r10,24");
        if(r0 > 31) {
            r0 = V8;
            r10 = *(r0 + c);
            asm("clrlwi	r0,r10,24");
            if(r0 <= 126) {
                goto L00040214;
            }
        }
        r0 = 46;
        goto L00040220;
L00040214:
        r0 = *(V8 + c);
L00040220:
        *(r9 + 16) = r0;
        c = c + 1;
    }
    while(c <= 15) {
        r9 = & c;
        r0 = *r9;
        *( & V8 + r0 + len + 16) = 32;
        *r9 = r0 + 1;
    }
    strcpy( & buff + len + c, "|");
    return(printf("%s\n", & buff));
}

/*	Procedure: 0x000402C4 - 0x000403D3
 *	Argument size: -140
 *	Local size: 144
 *	Save regs size: 0
 */

hexdump(char * fname)
{
	unsigned char  buff[16];
	unsigned long  offset;
	FILE* fp;
	struct stat st;
	int cnt;



    V8 = r3;
    if(stat(V8, & st) != 0) {
        fp = fopen(V8, "rb");
        if(fp != 0) {
            offset = 0;
            while(offset < V4c) {
                cnt = fread( & buff, 1, 16, fp);
                if(cnt == 0) {
                    break;
                }
                dumpline( & buff, offset, cnt);
                offset = offset + cnt;
            }
            goto L000403ac;
            goto L000403ac;
L000403ac:
            fclose(fp);
            r3 = 0;
        } else {
            perror(V8);
            r3 = 1;
        }
    } else {
        perror(V8);
        r3 = 1;
    }
    return(r3);
}

/*	Procedure: 0x000403D4 - 0x00040473
 *	Argument size: -24
 *	Local size: 32
 *	Save regs size: 0
 */

main(int argc, char ** argv)
{
	int i;
	int errs;



    V8 = r3;
    Vc = r4;
    errs = 0;
    i = 1;
    while(i < V8) {
        r0 = i;
        r9 = r0;
        asm("rlwinm	r0,r9,2,0,29");
        errs = errs + hexdump( *(r0 + Vc));
        i = i + 1;
    }
    r0 = errs;
    r3 = r0;
    return(r3);
}

/*	Procedure: 0x00040474 - 0x000404DB
 *	Argument size: -32
 *	Local size: 32
 *	Save regs size: 0
 */

stat()
{



    r29 = r3;
    r28 = r4;
    r0 = _xstat(1, r29, r28);
    r3 = r0;
    return(r3);
}

/*	Procedure: 0x000404DC - 0x00040517
 *	Argument size: -16
 *	Local size: 16
 *	Save regs size: 0
 */

_start()
{



    main();
    while(1) {
    }
    goto L000404f8;
}

/*	Procedure: 0x00040518 - 0x00040533
 *	Argument size: -16
 *	Local size: 16
 *	Save regs size: 0
 */

__main()
{



    return(r3);
}

/*	Procedure: 0x00040534 - 0x0004059B
 *	Argument size: -136
 *	Local size: 144
 *	Save regs size: 0
 */

printf(char * format, char * fmt)
{



    V8 = r3;
    Vc = R4;
    V10 = R5;
    V14 = R6;
    V18 = R7;
    V1c = R8;
    V20 = R9;
    V24 = Ra;
    != ? L00040588 : ;
    asm("stfd	f1,40(r31)");
    asm("stfd	f2,48(r31)");
    asm("stfd	f3,56(r31)");
    asm("stfd	f4,64(r31)");
    asm("stfd	f5,72(r31)");
    asm("stfd	f6,80(r31)");
    asm("stfd	f7,88(r31)");
    asm("stfd	f8,96(r31)");
    asm("stfd	f9,104(r31)");
    V70 = r3;
    return(r3);
}

/*	Procedure: 0x0004059C - 0x00040603
 *	Argument size: -128
 *	Local size: 144
 *	Save regs size: 0
 */

fprintf(struct _IO_FILE* fp, char * format, FILE* fp, char * fmt)
{



    V70 = r3;
    Vc = r4;
    V10 = R5;
    V14 = R6;
    V18 = R7;
    V1c = R8;
    V20 = R9;
    V24 = Ra;
    != ? L000405f0 : ;
    asm("stfd	f1,40(r31)");
    asm("stfd	f2,48(r31)");
    asm("stfd	f3,56(r31)");
    asm("stfd	f4,64(r31)");
    asm("stfd	f5,72(r31)");
    asm("stfd	f6,80(r31)");
    asm("stfd	f7,88(r31)");
    asm("stfd	f8,96(r31)");
    asm("stfd	f9,104(r31)");
    V74 = r4;
    return(r3);
}

/*	Procedure: 0x00040604 - 0x0004066B
 *	Argument size: -128
 *	Local size: 144
 *	Save regs size: 0
 */

sprintf(char * dst, char * format, char * dst, char * fmt)
{



    V70 = r3;
    Vc = r4;
    V10 = R5;
    V14 = R6;
    V18 = R7;
    V1c = R8;
    V20 = R9;
    V24 = Ra;
    != ? L00040658 : ;
    asm("stfd	f1,40(r31)");
    asm("stfd	f2,48(r31)");
    asm("stfd	f3,56(r31)");
    asm("stfd	f4,64(r31)");
    asm("stfd	f5,72(r31)");
    asm("stfd	f6,80(r31)");
    asm("stfd	f7,88(r31)");
    asm("stfd	f8,96(r31)");
    asm("stfd	f9,104(r31)");
    V74 = r4;
    return(r3);
}

/*	Procedure: 0x0004066C - 0x00040697
 *	Argument size: 0
 *	Local size: 32
 *	Save regs size: 0
 */

fread(void * b, size_t i, size_t l, FILE* p)
{



    V8 = r3;
    Vc = R4;
    V10 = R5;
    V14 = R6;
    return(V8);
}

/*	Procedure: 0x00040698 - 0x000406C3
 *	Argument size: 0
 *	Local size: 32
 *	Save regs size: 0
 */

fwrite(void * b, size_t i, size_t l, FILE* p)
{



    V8 = r3;
    Vc = R4;
    V10 = R5;
    V14 = R6;
    return(V8);
}

/*	Procedure: 0x000406C4 - 0x000406E7
 *	Argument size: -16
 *	Local size: 32
 *	Save regs size: 0
 */

fopen(char * n, char * m)
{



    V8 = r3;
    Vc = R4;
    return(V8);
}

/*	Procedure: 0x000406E8 - 0x0004070F
 *	Argument size: -24
 *	Local size: 32
 *	Save regs size: 0
 */

fclose(FILE* fp)
{



    V8 = r3;
    r3 = 0;
    return(r3);
}

/*	Procedure: 0x00040710 - 0x0004072F
 *	Argument size: -24
 *	Local size: 32
 *	Save regs size: 0
 */

perror(char * p)
{



    V8 = r3;
    return(V8);
}

/*	Procedure: 0x00040730 - 0x0004075B
 *	Argument size: -24
 *	Local size: 32
 *	Save regs size: 0
 */

exit(int x)
{



    V8 = r3;
    while(1) {
    }
    goto L00040744;
}

/*	Procedure: 0x0004075C - 0x0004077F
 *	Argument size: -16
 *	Local size: 32
 *	Save regs size: 0
 */

__overflow(/* unknown */ void * f, int x)
{



    V8 = r3;
    Vc = R4;
    return(V8);
}

/*	Procedure: 0x00040780 - 0x000407AB
 *	Argument size: -16
 *	Local size: 32
 *	Save regs size: 0
 */

open(char * name, int mode)
{



    V8 = r3;
    Vc = r4;
    r3 = -1;
    return(r3);
}

/*	Procedure: 0x000407AC - 0x000407DB
 *	Argument size: -8
 *	Local size: 32
 *	Save regs size: 0
 */

read(int fd, char * buff, int size)
{



    V8 = r3;
    Vc = r4;
    V10 = r5;
    r3 = 0;
    return(r3);
}

/*	Procedure: 0x000407DC - 0x0004080B
 *	Argument size: -8
 *	Local size: 32
 *	Save regs size: 0
 */

write(int fd, char * buff, int size)
{



    V8 = r3;
    Vc = r4;
    V10 = r5;
    r3 = 0;
    return(r3);
}

/*	Procedure: 0x0004080C - 0x00040827
 *	Argument size: -16
 *	Local size: 16
 *	Save regs size: 0
 */

_fxstat()
{



    return(r3);
}

/*	Procedure: 0x00040828 - 0x00040843
 *	Argument size: -16
 *	Local size: 16
 *	Save regs size: 0
 */

_xstat()
{



    return(r3);
}

/*	Procedure: 0x00040844 - 0x000408B3
 *	Argument size: -16
 *	Local size: 32
 *	Save regs size: 0
 */

strcpy(char * dst, char * src)
{
	char * d;



    V8 = r3;
    Vc = r4;
    d = V8;
    while(1) {
        r9 = V8;
        r11 = & Vc;
        r10 = *r11;
        r0 = *r10;
        *r9 = r0;
        asm("clrlwi	r0,r0,24");
        *r11 = r10 + 1;
        V8 = r9 + 1;
        if(r0 == 0) {
            break;
        }
    }
    r0 = d;
    r3 = r0;
    return(r3);
}

/*	Procedure: 0x000408B4 - 0x0004092F
 *	Argument size: -16
 *	Local size: 32
 *	Save regs size: 0
 */

strcat(char * dst, char * src)
{
	char * d;



    V8 = r3;
    Vc = r4;
    r0 = V8;
    d = r0;
    while(1) {
        r11 = *V8;
        asm("clrlwi	r0,r11,24");
        if(r0 == 0) {
            break;
        }
        r0 = V8;
        V8 = r0 + 1;
    }
    strcpy(V8, Vc);
    r0 = d;
    r3 = r0;
    return(r3);
}

/*	Procedure: 0x00040930 - 0x00040997
 *	Argument size: -24
 *	Local size: 32
 *	Save regs size: 0
 */

strlen(char * src)
{
	int len;



    V8 = r3;
    r0 = 0;
    len = 0;
    while(1) {
        r11 = *V8;
        asm("clrlwi	r0,r11,24");
        if(r0 == 0) {
            break;
        }
        V8 = V8 + 1;
        r0 = len;
        len = r0 + 1;
    }
    r0 = len;
    r3 = r0;
    return(r3);
}

/* address  size  */
/* 0x00000000       0 */ struct _IO_FILE_plus	IO_stdin_;
/* 0x00000000       0 */ struct _IO_FILE_plus	IO_stdout_;
/* 0x00000000       0 */ struct _IO_FILE_plus	IO_stderr_;
/* 0x00000000       0 */ FILE	_iob;
/* 0x00040074       0 */ void 	dumpline(unsigned char *, unsigned long , int);
/* 0x00040074       0 */ /* unknown */ void 	/home/cg/usr/src/cmd/wrec/exppc/;
/* 0x00040074       0 */ /* unknown */ void 	hd.c;
/* 0x000402c4     272 */ int	hexdump(char *);
/* 0x000403d4     160 */ int	main(int, char **);
/* 0x00040474     104 */ int	stat();
/* 0x000404dc       0 */ int	_start();
/* 0x000404dc       0 */ /* unknown */ void 	;
/* 0x000404dc       0 */ /* unknown */ void 	/home/cg/usr/gccppc/lib/;
/* 0x000404dc       0 */ /* unknown */ void 	lib.c;
/* 0x00040518      28 */ int	__main();
/* 0x00040534     104 */ int	printf(char *, char *);
/* 0x0004059c     104 */ int	fprintf(struct _IO_FILE*, char *, FILE*, char *);
/* 0x00040604     104 */ int	sprintf(char *, char *, char *, char *);
/* 0x0004066c      44 */ size_t	fread(void *, size_t, size_t, FILE*);
/* 0x00040698      44 */ size_t	fwrite(void *, size_t, size_t, FILE*);
/* 0x000406c4      36 */ FILE*	fopen(char *, char *);
/* 0x000406e8      40 */ int	fclose(FILE*);
/* 0x00040710      32 */ void 	perror(char *);
/* 0x00040730      44 */ int	exit(int);
/* 0x0004075c      36 */ int	__overflow(/* unknown */ void *, int);
/* 0x00040780      44 */ int	open(char *, int);
/* 0x000407ac      48 */ int	read(int, char *, int);
/* 0x000407dc      48 */ int	write(int, char *, int);
/* 0x0004080c      28 */ int	_fxstat();
/* 0x00040828      28 */ int	_xstat();
/* 0x00040844     112 */ char *	strcpy(char *, char *);
/* 0x000408b4     124 */ char *	strcat(char *, char *);
/* 0x00040930       0 */ int	strlen(char *);
/* 0x00040998       0 */ /* unknown */ void 	;
/* 0x000489bc       0 */ /* unknown */ void 	_SDA2_BASE_;
/* 0x000809d0       0 */ /* unknown */ void 	_IO_stdout_;
/* 0x000809d4       0 */ /* unknown */ void 	_IO_stderr_;
/* 0x000809d8       0 */ /* unknown */ void 	_IO_stdin_;
/* 0x000809dc       0 */ /* unknown */ void 	__iob;
/* 0x000889d0       0 */ /* unknown */ void 	_SDA_BASE_;
#if 0 /* auxiliary information */
# Current option values:
option: -compactcalls
option: +compactexprs
option: +compactifs
option: +compset
option: -dfoproc
option: -disasmonly
option: -displaylabels
option: +docase
option: +dofor
option: +doifs
option: +doloops
option: +donullgotos
option: +dopackloops
option: +dopackstmt
option: -doremlabs
option: +dosimplify
option: +dosort
option: +dostmts
option: +doswitch
option: +dowhile
option: -dumpaddrs
option: -dumpcall
option: -dumpcomments
option: -dumpdfo
option: -dumpsblocks
option: -dumpsets
option: -dumpsizes
option: -flag16
option: +fullscreen
option: -getpattern
option: -help
option: -hexconst
option: -html
option: +insertlabels
option: -int16
option: +int32
option: -interactive
option: +locals
option: -nohtmltabs
option: -okclone
option: -outprocs
option: -outrefs
option: -overrule
option: +rdonly
option: -showjump
option: -showlabel
option: -showprotosym
option: -showreg
option: -showstring
option: -silent
option: +simplifyexprs
option: -strallregions
option: -traceall
option: -tracesets
option: +types
option: +usesymtab
option: -validatebr
option: -validatereg
option: +validatestr
#endif