/*	This file was automatically created by
 *	Reverse Engineering Compiler 1.5f (C) Giampiero Caprino (Feb 29 2000)
 *	Input file: 'lldrx.o'
 */

/*	Procedure: 0x00000000 - 0x0000029C
 *	Argument size: 4
 *	Local size: 12
 *	Save regs size: 16
 */

HandleDataReceive(A20)
/* unknown */ void  A20;
{
	/* unknown */ void  ebx;
	/* unknown */ void  ebp;
	/* unknown */ void  esi;
	/* unknown */ void  edi;
	/* unknown */ void  V14;
	/* unknown */ void  V1b;



    *HandleDataReceive = *HandleDataReceive + 1;
    al = *(A20 + 9);
    if(!(al & 64)) {
        L0000001d();
        eax = L00000026(114, 6, 82, 6);
        if(*HandleDataReceive != HandleDataReceive) {
            if(*HandleDataReceive == HandleDataReceive) {
                ecx = A20;
                ax = ( *(ecx + 6) & 255) << 8;
                eax = LLDRepeat(ecx, eax + ( *(ecx + 7) & 255) + -4 & 65535);
            }
        }
        ecx = A20;
        al = *(ecx + 9);
        if(al < 0) {
            esi = ecx + 30;
        } else {
            esi = A20 + 18;
        }
        edi = HandleDataReceive;
        ecx = 6;
        asm("cld");
        asm("repe cmpsb");
        if(al & HandleDataReceive) {
            goto L00000295;
        }
    }
    if(al < 0) {
        (save) & V1b;
        eax = A20 + 30;
    } else {
        (save) & V1b;
        eax = A20 + 18;
    }
    (save)eax;
    L000000b3();
    esp = esp + 8;
    eax = (V1b & 255) << 6;
    ebp = eax + HandleDataReceive;
    *(eax + 60) = 255;
    if(*(eax + 34) == HandleDataReceive) {
        *(eax + 34) = 1;
        *(eax + 32) = 255;
        LLDDuplicateDetection(A20, ebp);
        goto L00000117;
        esi = esi + HandleDataReceive;
    }
    if(LLDDuplicateDetection(A20, ebp) == 0) {
L00000117:
        if(!( *(A20 + 9) & 64)) {
            if(*HandleDataReceive != HandleDataReceive) {
                goto L00000130;
            }
            *(ebp + 16) = 255;
        } else {
L00000130:
            *(ebp + 16) = HandleDataReceive;
        }
        ecx = A20;
        if(*(ecx + 9) < HandleDataReceive) {
            ebx = ecx + 18;
            edi = ecx + 30;
            if(*HandleDataReceive != HandleDataReceive) {
                esi = ebx;
                ecx = 6;
                asm("cld");
                asm("repe cmpsb");
                if(al & HandleDataReceive) {
                    goto L00000184;
                }
            }
            L00000160();
            *(ebp + 24) = ax;
            *(ebp + 17) = 1;
            *(ebp + 21) = 255;
            *(ebp + 10) = *(A20 + 18);
            *(ebp + 14) = *(ebx + 4);
        } else {
L00000184:
            *(ebp + 17) = HandleDataReceive;
            *(ebp + 21) = HandleDataReceive;
        }
        ecx = A20;
        bx = ( *(ecx + 6) & 255) << 8;
        ebx = ebx + ( *(ecx + 7) & 255) + -4;
        *HandleDataReceive = 12;
        V14 = ecx + 12;
        if(*(A20 + 9) >= HandleDataReceive) {
            goto L0000021e;
        }
        L000001c2();
        eax = L000001cb(48, 2, 122, 2);
        ecx = A20;
        if(*(ecx + 12) & 1) {
            goto L00000205;
        }
        if(*(ecx + 24) & 1) {
            goto L00000205;
        }
        if(*HandleDataReceive != HandleDataReceive) {
            goto L00000205;
        }
        esi = ecx + 24;
        edi = HandleDataReceive;
        ecx = 6;
        asm("cld");
        asm("repe cmpsb");
        if(!(al & HandleDataReceive)) {
L00000205:
            V14 = V14 + 12;
            ebx = ebx + -12;
            *HandleDataReceive = 24;
            *HandleDataReceive = *HandleDataReceive + -12;
L0000021e:
            edx = A20;
            *HandleDataReceive = bx;
            if(!( *(edx + 11) & 240)) {
                (save)ebp;
                (save)edx;
                (save)bx & 65535;
                (save)V14;
                eax = LLDRxFragments();
            } else {
                L00000249(V14);
                if(al != 0) {
                    eax = ProcessProximPkt(V14, bx & 65535, A20);
                    goto L00000295;
                }
                *HandleDataReceive = *HandleDataReceive + 1;
                eax = L0000028e(V14, bx & 65535, HandleDataReceive, *(A20 + 4) & 255);
            }
        }
    }
L00000295:
}

/*	Procedure: 0x0000029D - 0x0000029F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L0000029D()
{



    esi = esi + HandleDataReceive;
}

stack space not deallocated on return
/*	Procedure: 0x000002A0 - 0x000007A5
 *	Argument size: 44
 *	Local size: 24
 *	Save regs size: 16
 */

LLDReceive(A38, A3c, A3e, A40, A44, A45, A46, A48, A4a, A4c, A4f, A52, A54, A56, A58, A5a, A5c, A60)
/* unknown */ void  A38;
/* unknown */ void  A3c;
/* unknown */ void  A3e;
/* unknown */ void  A40;
/* unknown */ void  A44;
/* unknown */ void  A45;
/* unknown */ void  A46;
/* unknown */ void  A48;
/* unknown */ void  A4a;
/* unknown */ void  A4c;
/* unknown */ void  A4f;
/* unknown */ void  A52;
/* unknown */ void  A54;
/* unknown */ void  A56;
/* unknown */ void  A58;
/* unknown */ void  A5a;
/* unknown */ void  A5c;
/* unknown */ void  A60;
{
	/* unknown */ void  ebp;
	/* unknown */ void  esi;
	/* unknown */ void  edi;



    *HandleDataReceive = *HandleDataReceive + 1;
    A3e = A58;
    esi = A54;
    edi = A5c;
    ebp = *(esi + 48);
    bx = *(esi + 52);
    A4c = bx;
    if(*(esi + 44) == 1) {
        if(bx < di) {
            L000002db(99, 2);
        }
    }
    if(*HandleDataReceive != HandleDataReceive) {
        L000002f1();
        L000002fa(50, 2, 98, 2);
    }
    A48 = di;
    A46 = HandleDataReceive;
    A4a = HandleDataReceive;
    si = *HandleDataReceive - A3e;
    A40 = si;
    edx = (A3e & 65535) + ( *HandleDataReceive & 65535) + *HandleDataReceive;
    if(si > di) {
        A40 = di;
        goto L00000524;
        goto L00000350;
L00000372:
        if(bx > 1538) {
            *HandleDataReceive = *HandleDataReceive + 1;
            L00000384();
            L0000038d();
            L00000396();
            L0000039f(67, 4, 100, 4, 97, 4, 66, 4);
            L000003ab();
            L000003b4();
            L000003bd();
            L000003c6(101, 4, 76, 4, 121, 4, 112, 4);
            (save)4;
            (save)110;
            L000003d2();
            (save)4;
            (save) *L00000001 & 255;
            L000003e2();
            (save)4;
            eax = *HandleDataReceive & 255;
        } else {
            eax = A40 & 65535;
            ecx = eax >> 2;
            edi = ebp;
            esi = edx;
            asm("cld");
            asm("rep movsd");
            if(!(al & 2)) {
                *edi = *esi;
                edi = edi + 4;
                esi = esi + 4;
            }
            if(!(al & 1)) {
                *edi = *esi;
                edi = edi + 1;
                esi = esi + 1;
            }
            ebp = ebp + eax;
            A38 = A40;
            A4c = A4c - bx;
            A48 = A48 - bx;
            A46 = A46 + bx;
            goto L0000074a;
            esi = esi + HandleDataReceive;
            goto L00000430;
L0000043f:
            *HandleDataReceive = *HandleDataReceive + 1;
            L00000448();
            L00000451();
            L0000045a();
            L00000463(67, 4, 100, 4, 97, 4, 66, 4);
            L0000046f();
            L00000478();
            L00000481();
            L0000048a(101, 4, 76, 4, 121, 4, 112, 4);
            (save)4;
            (save)110;
            L00000496();
            (save)4;
            (save)A58 >> 8 & 255;
            L000004ab();
            (save)4;
            eax = A60 & 255;
        }
        (save)eax;
        L000004b9();
        eax = 0;
        esp = esp + 24;
    } else {
L00000524:
        while(A40 != HandleDataReceive) {
L00000350:
            si = A4a;
            if(si >= *(A54 + 44)) {
                break;
            }
            A38 = A40;
            if(A4c >= bx) {
                goto L00000372;
            }
L00000430:
            if(A4c > 1538) {
                goto L0000043f;
            }
            eax = A4c & 65535;
            ecx = eax >> 2;
            edi = ebp;
            esi = edx;
            asm("cld");
            asm("rep movsd");
            if(!(al & 2)) {
                *edi = *esi;
                edi = edi + 4;
                esi = esi + 4;
            }
            if(!(al & 1)) {
                *edi = *esi;
                edi = edi + 1;
                esi = esi + 1;
            }
            A38 = A4c;
            A48 = A48 - bx;
            A46 = A46 + bx;
            edx = edx + eax;
            A40 = A40 - bx;
            A4a = A4a + 1;
            esi = A54;
            bx = A4a;
            if(bx >= *(esi + 44)) {
                continue;
            }
            eax = (bx & 65535) << 3;
            ebp = *(eax + esi + 48);
            A4c = *(eax + esi + 52);
        }
        goto L0000074a;
L00000555:
        if(A45 != HandleDataReceive) {
            *(( *HandleDataReceive & 65535) + ( *HandleDataReceive & 65535) + *HandleDataReceive) = A4f & 255;
            *HandleDataReceive = *HandleDataReceive + 1;
        }
        eax = A46 & 65535;
        goto L0000079e;
L0000074a:
        while(1) {
            A45 = HandleDataReceive;
            do {
                if(A48 == HandleDataReceive) {
                    goto L0000075b;
                }
                if(A4c == HandleDataReceive) {
                    A4a = A4a + 1;
                    bx = A4a;
                    if(bx >= *(A54 + 44)) {
                        goto L00000555;
                    }
                    eax = (A4a & 65535) << 3;
                    esi = A54;
                    ebp = *(eax + esi + 48);
                    A4c = *(eax + esi + 52);
                    if(A45 != HandleDataReceive) {
                        *(ebp + HandleDataReceive) = A4f & 255;
                        ebp = ebp + 1;
                        *(( *HandleDataReceive & 65535) + ( *HandleDataReceive & 65535) + *HandleDataReceive) = A4f & 255;
                        *HandleDataReceive = *HandleDataReceive + 1;
                        A4c = A4c - 1;
                        A46 = A46 + 1;
                        A48 = A48 - 1;
                        A45 = HandleDataReceive;
                    }
                }
                A38 = A48;
                A40 = bx;
                A38 = A4c;
                if(A48 > bx) {
                    A40 = bx;
                }
                esi = A40;
                if(!(esi & 1)) {
                    A45 = 255;
                    esi = esi - 1;
                    A40 = si;
                }
                A38 = A44 & 65535;
                A3c = A38;
                L00000644(ebp, A3c, *HandleDataReceive & 255);
                edi = ( *HandleDataReceive & 65535) + *HandleDataReceive + ( *HandleDataReceive & 65535);
                esi = ebp;
                ecx = A38 >> 2;
                asm("cld");
                asm("rep movsd");
                if(!(bl & 2)) {
                    *edi = *esi;
                    edi = edi + 4;
                    esi = esi + 4;
                }
                if(!(bl & 1)) {
                    *edi = *esi;
                    edi = edi + 1;
                    esi = esi + 1;
                }
                esi = A40;
                *HandleDataReceive = *HandleDataReceive + si;
                A48 = A48 - si;
                A46 = A46 + si;
                ebp = ebp + A38;
                A4c = A4c - si;
                if(A45 == HandleDataReceive) {
                    continue;
                }
                edi = & A56;
                L000006b9(edi, 2, *HandleDataReceive & 255);
                *(ebp + HandleDataReceive) = A5a;
                ebp = ebp + 1;
                *(( *HandleDataReceive & 65535) + ( *HandleDataReceive & 65535) + *HandleDataReceive) = A5a;
                A58 = A58 - 1;
                A52 = A52 + 1;
                A54 = A54 - 1;
                *HandleDataReceive = *HandleDataReceive + 1;
                if(A48 == HandleDataReceive) {
                    goto L0000075b;
                }
            } while(A4c == HandleDataReceive);
            *(ebp + HandleDataReceive) = *(edi + 1);
            ebp = ebp + 1;
            *(( *HandleDataReceive & 65535) + ( *HandleDataReceive & 65535) + *HandleDataReceive) = *(edi + 1);
            *HandleDataReceive = *HandleDataReceive + 1;
            A4c = A4c - 1;
            A46 = A46 + 1;
            A48 = A48 - 1;
        }
L0000075b:
        if(A45 != HandleDataReceive) {
            if(*HandleDataReceive != A46) {
                *(( *HandleDataReceive & 65535) + ( *HandleDataReceive & 65535) + *HandleDataReceive) = A4f;
                *HandleDataReceive = *HandleDataReceive + 1;
            }
        }
        eax = A46 & 65535;
    }
L0000079e:
}

/*	Procedure: 0x000007A6 - 0x000007AF
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L000007A6()
{



    esi = esi + HandleDataReceive;
    edi = edi + HandleDataReceive;
}

/*	Procedure: 0x000007B0 - 0x000007EF
 *	Argument size: 12
 *	Local size: 0
 *	Save regs size: 4
 */

LLDRawReceive(A8, Ac, A10)
/* unknown */ void  A8;
/* unknown */ void  Ac;
/* unknown */ void  A10;
{
	/* unknown */ void  ebx;



    *HandleDataReceive = HandleDataReceive;
    0;
    return(LLDReceive(A8, Ac & 65535, A10 & 65535) & 65535);
}

/*	Procedure: 0x000007F0 - 0x000008FC
 *	Argument size: 8
 *	Local size: 0
 *	Save regs size: 8
 */

LLDDuplicateDetection(Ac, A10)
/* unknown */ void  Ac;
/* unknown */ void  A10;
{
	/* unknown */ void  esi;



    esi = A10;
    if(CheckRoamNotify(Ac) != 0) {
        eax = 0;
        goto L000008fa;
    }
    dl = *(Ac + 10);
    al = *(Ac + 11);
    if(!(al & 240)) {
        if(dl != *(esi + 35)) {
            if(bl = al & 15) {
                goto L00000870;
            }
            if(*(esi + 32) + 1 == bl) {
                if(dl == *(esi + 33)) {
                    goto L00000870;
                }
            }
            edx = *(esi + 40);
            if(edx != 0) {
                *edx = *HandleDataReceive;
                *HandleDataReceive = *(esi + 40);
                *(esi + 44) = HandleDataReceive;
                *(esi + 38) = HandleDataReceive;
                *(esi + 40) = HandleDataReceive;
            }
        }
        *(esi + 32) = 255;
        eax = 255;
        goto L000008fa;
        esi = esi + HandleDataReceive;
L00000870:
        *(esi + 33) = dl;
        *(esi + 32) = bl;
        L0000087b();
        bl = bl + 48;
        L0000088a(bl & 255, 11, 70, 11);
    } else {
        if(dl == *(esi + 35)) {
            *HandleDataReceive = *HandleDataReceive + 1;
            *(esi + 32) = 255;
            L000008a7();
            L000008b0();
            L000008b9(80, 14, 85, 14, 68, 14);
            eax = 255;
            goto L000008fa;
        }
        *(esi + 32) = 255;
        *(esi + 35) = dl;
        edx = *(esi + 40);
        if(edx != 0) {
            *edx = *HandleDataReceive;
            *HandleDataReceive = *(esi + 40);
            *(esi + 44) = HandleDataReceive;
            *(esi + 38) = HandleDataReceive;
            *(esi + 40) = HandleDataReceive;
        }
    }
    eax = 0;
L000008fa:
}

/*	Procedure: 0x000008FD - 0x000008FF
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L000008FD()
{



    esi = esi + HandleDataReceive;
}

/*	Procedure: 0x00000900 - 0x00000B19
 *	Argument size: 16
 *	Local size: 0
 *	Save regs size: 0
 */

LLDRxFragments(A4, A8, Ac, A10)
/* unknown */ void  A4;
/* unknown */ void  A8;
/* unknown */ void  Ac;
/* unknown */ void  A10;
{
	/* unknown */ void  Vffffffff;



    esp = esp - 4;
    (save)A8;
    (save)edi;
    (save)esi;
    (save)A10;
    esi = A4;
    if(!(Vffffffff = *(Ac + 11) & 15)) {
        eax = *(A10 + 40);
        if(eax != 0) {
            *(A10 + 44) = eax + 4;
            *(A10 + 38) = HandleDataReceive;
        } else {
            eax = *HandleDataReceive;
            if(eax != 0) {
                *(A10 + 40) = eax;
                *(A10 + 44) = eax + 4;
                goto L00000969;
            }
            if(CheckRxBuffTimeOut() == 0) {
                goto L000009a7;
            }
            eax = *HandleDataReceive;
            *(A10 + 40) = eax;
            *(A10 + 44) = eax + 4;
L00000969:
            *(A10 + 38) = HandleDataReceive;
            *HandleDataReceive = *eax;
        }
        edi = *(A10 + 44);
        ecx = ( *HandleDataReceive & 65535) >> 2;
        asm("cld");
        asm("rep movsd");
        if(!(al & 2)) {
            *edi = *esi;
            edi = edi + 4;
            esi = esi + 4;
        }
        if(!(al & 1)) {
            *edi = *esi;
            edi = edi + 1;
            esi = esi + 1;
        }
        *(A10 + 44) = *(A10 + 44) + ( *HandleDataReceive & 65535);
    } else {
        if(*(A10 + 40) == HandleDataReceive) {
L000009a7:
            *(A10 + 32) = 255;
            eax = 255;
            goto L00000b14;
        }
        edi = *(A10 + 44);
        esi = esi + 12;
        ecx = ( *HandleDataReceive & 65535) + -12 >> 2;
        asm("cld");
        asm("rep movsd");
        if(!(al & 2)) {
            *edi = *esi;
            edi = edi + 4;
            esi = esi + 4;
        }
        if(!(al & 1)) {
            *edi = *esi;
            edi = edi + 1;
            esi = esi + 1;
        }
        *(A10 + 44) = ( *HandleDataReceive & 65535) + *(A10 + 44) + -12;
    }
    dx = *HandleDataReceive;
    if(bp > dx) {
        L00000a0e( *(A10 + 44), A8 - edx & 65535, *HandleDataReceive & 255);
        eax = bp & 65535;
        *(A10 + 44) = *(A10 + 44) + eax - ( *HandleDataReceive & 65535);
    }
    ecx = Ac;
    dx = ( *(ecx + 6) & 255) << 8;
    edx = edx + ( *(ecx + 7) & 255);
    ax = edx + -16;
    if(*(ecx + 9) < HandleDataReceive) {
        *HandleDataReceive = *HandleDataReceive + -12;
        eax = edx + -28;
    }
    *(A10 + 38) = *(A10 + 38) + ax;
    *( *(A10 + 40) + 1556) = L00000a5a();
    eax = *(A10 + 40);
    *(eax + 1560) = A10;
    edi = Ac;
    if(*(edi + 11) >> 4 == Vffffffff) {
        edx = *(A10 + 40) + 4;
        *HandleDataReceive = edx;
        eax = *(edi + 9) & 15 & 255;
        eax = *(A10 + 38) - eax + 12;
        *HandleDataReceive = ax;
        *HandleDataReceive = *HandleDataReceive + -12;
        *HandleDataReceive = *HandleDataReceive + 1;
        *HandleDataReceive = *HandleDataReceive + 1;
        *HandleDataReceive = ax;
        L00000adb(edx, *HandleDataReceive & 65535, HandleDataReceive, *(edi + 4) & 255);
        edx = *(A10 + 40);
        *edx = *HandleDataReceive;
        *HandleDataReceive = *(A10 + 40);
        *(A10 + 40) = HandleDataReceive;
        *(A10 + 44) = HandleDataReceive;
        *(A10 + 38) = HandleDataReceive;
        *(A10 + 35) = *(edi + 10);
        *(A10 + 32) = 255;
    }
    eax = 0;
L00000b14:
    (restore)A10;
    (restore)esi;
    (restore)edi;
    (restore)A8;
    (restore)ecx;
}

/*	Procedure: 0x00000B1A - 0x00000B1F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00000B1A()
{



    esi = esi + HandleDataReceive;
}

/*	Procedure: 0x00000B20 - 0x00000C8C
 *	Argument size: 8
 *	Local size: 16
 *	Save regs size: 12
 */

LLDRepeat(A20, A24)
/* unknown */ void  A20;
/* unknown */ void  A24;
{
	/* unknown */ void  Vc;
	/* unknown */ void  ebx;
	/* unknown */ void  V10;
	/* unknown */ void  edi;
	/* unknown */ void  V14;
	/* unknown */ void  V18;



    L00000b33();
    L00000b3c();
    L00000b45();
    L00000b4e(101, 6, 112, 6, 101, 6, 82, 6);
    (save)6;
    (save)97;
    L00000b5a();
    (save)6;
    edi = A24;
    (save)116;
    L00000b65();
    (save) *HandleDataReceive & 255;
    (save)edi - *HandleDataReceive & 65535;
    (save)A20 + ( *HandleDataReceive & 65535) + 12;
    L00000b8f();
    *HandleDataReceive = bx;
    *A20 = 66;
    *(A20 + 1) = 127;
    *(A20 + 2) = HandleDataReceive;
    *(A20 + 3) = HandleDataReceive;
    *(A20 + 4) = 128;
    esp = esp + 28;
    if(*HandleDataReceive == 1) {
        *(A20 + 4) = 129;
    }
    *(A20 + 5) = 112;
    *(A20 + 6) = (di & 65535) + 4 >> 8;
    *(A20 + 7) = edi + 4;
    dx = *HandleDataReceive;
    if(*(A20 + 9) < HandleDataReceive) {
        edx = edx + 12;
    }
    dx = dx + 12;
    if(!( *(A20 + 12) & 1)) {
        eax = L00000bf9(A20, dx & 65535);
    } else {
        edi = A20 + 12;
        V14 = *(A20 + 12);
        ebx = A20 + 18;
        V18 = *(edi + 4);
        Vc = *(A20 + 18);
        V10 = *(ebx + 4);
        *(A20 + 12) = *(A20 + 24);
        *(edi + 4) = *(A20 + 28);
        if(!( *(A20 + 12) & 1)) {
            *(A20 + 4) = *(A20 + 4) | 32;
        }
        *(A20 + 9) = *(A20 + 9) | 128;
        *(A20 + 18) = *HandleDataReceive;
        *(ebx + 4) = *L00000004;
        L00000c61(A20, dx & 65535);
        *(A20 + 12) = V14;
        eax = V18;
        *(edi + 4) = ax;
        *(A20 + 18) = Vc;
        *(ebx + 4) = V10;
    }
}

/*	Procedure: 0x00000C8D - 0x00000C8F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00000C8D()
{



    esi = esi + HandleDataReceive;
}

/*	Procedure: 0x00000C90 - 0x00000D85
 *	Argument size: 12
 *	Local size: 16
 *	Save regs size: 16
 */

SendLLDPingResponse(A24, A28, A2c)
/* unknown */ void  A24;
/* unknown */ void  A28;
/* unknown */ void  A2c;
{
	/* unknown */ void  ebx;
	/* unknown */ void  V10;
	/* unknown */ void  esi;
	/* unknown */ void  edi;
	/* unknown */ void  V16;
	/* unknown */ void  V1e;



    esi = A24;
    V16 = bp;
    V1e = A2c;
    L00000cb2();
    L00000cbb();
    L00000cc4();
    L00000ccd(115, 7, 101, 7, 82, 7, 80, 7);
    eax = L00000cd9(112, 7);
    ebx = *HandleDataReceive;
    if(ebx != 0) {
        *HandleDataReceive = *(ebx + 1568);
        edi = ebx + 18;
        V10 = edi;
        ecx = (V16 & 65535) >> 2;
        asm("cld");
        asm("rep movsd");
        if(!(al & 2)) {
            *edi = *esi;
            edi = edi + 4;
            esi = esi + 4;
        }
        if(!(al & 1)) {
            *edi = *esi;
            edi = edi + 1;
            esi = esi + 1;
        }
        *(ebx + 16) = bp;
        *(ebx + 10) = bp;
        *(ebx + 12) = ebx + 1572;
        *(ebx + 1572) = HandleDataReceive;
        edi = ebx + 24;
        *(ebx + 18) = *(ebx + 24);
        edx = V10;
        *(edx + 4) = *(edi + 4);
        *(ebx + 24) = *HandleDataReceive;
        *(edi + 4) = *L00000004;
        *(edx + 28) = V1e >> 8;
        *(V10 + 29) = V1e;
        eax = L00000d77(ebx + 4);
    }
}

/*	Procedure: 0x00000D86 - 0x00000D8F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00000D86()
{



    esi = esi + HandleDataReceive;
    edi = edi + HandleDataReceive;
}

/*	Procedure: 0x00000D90 - 0x00000DC4
 *	Argument size: 4
 *	Local size: 0
 *	Save regs size: 0
 */

CheckRoamNotify(A4)
/* unknown */ void  A4;
{



    ecx = 0;
    edx = A4 + 12;
    if(!( *(A4 + 9) & 32)) {
        if(*(edx + 24) == 14209) {
            if(*(edx + 26) == 65535) {
                if(*(edx + 42) == 19334) {
                    ecx = 1;
                }
            }
        }
        if(ecx == 0) {
            return(0);
        }
    }
    return(1);
    return(0);
}

/*	Procedure: 0x00000DC5 - 0x00000DCF
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00000DC5()
{



    esi = esi + HandleDataReceive;
    edi = edi + HandleDataReceive;
}

/*	Procedure: 0x00000DD0 - 0x00000E9A
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

CheckRxBuffTimeOut()
{
	/* unknown */ void  Vffffffff;



    esp = esp - 4;
    (save)esi;
    (save)ebx;
    esi = *HandleDataReceive;
    Vffffffff = HandleDataReceive;
    do {
        ecx = Vffffffff & 255;
        edx = ecx * 8 + HandleDataReceive - ecx;
        eax = (edx * 8 + HandleDataReceive - edx << 3) - ecx << 2;
        bx = L00000de1() - *(esi + eax + 1556);
        if(bx > 48000) {
            edx = *(esi + eax + 1560);
            ecx = *(edx + 40);
            if(ecx == 0) {
L00000e50:
                L00000e55();
                L00000e5e();
                L00000e67();
                L00000e70(82, 7, 69, 7, 84, 7, 66, 7);
                L00000e7c(82, 7);
            } else {
                *ecx = *HandleDataReceive;
                *HandleDataReceive = *(edx + 40);
                *(edx + 40) = HandleDataReceive;
                *(edx + 44) = HandleDataReceive;
                *(edx + 38) = HandleDataReceive;
                *(edx + 32) = 255;
            }
        }
        Vffffffff = Vffffffff + 1;
    } while(Vffffffff <= 2);
    goto L00000e97;
    esi = esi + HandleDataReceive;
    goto L00000e50;
L00000e97:
    (restore)ebx;
    (restore)esi;
    (restore)ecx;
    return(*HandleDataReceive);
}

/*	Procedure: 0x00000E9B - 0x00000E9F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00000E9B()
{



    esi = esi + HandleDataReceive;
}

/*	Procedure: 0x00000EA0 - 0x0000151A
 *	Argument size: 12
 *	Local size: 8
 *	Save regs size: 16
 */

ProcessProximPkt(A1c, A20, A24)
/* unknown */ void  A1c;
/* unknown */ void  A20;
/* unknown */ void  A24;
{
	/* unknown */ void  ebx;
	/* unknown */ void  V10;
	/* unknown */ void  esi;
	/* unknown */ void  edi;
	/* unknown */ void  V14;



    eax = A20;
    V14 = eax;
    esi = A1c;
    ebx = V14;
    if(*(esi + 26) == 4) {
        if(*(esi + 28) == 256) {
            goto L00000f25;
        }
    }
    dx = *HandleDataReceive;
    if(bx > dx) {
        eax = *HandleDataReceive & 255;
        V10 = eax;
        eax = *HandleDataReceive & 65535;
        V10 = bx;
        V10 = V10 - dx;
        esi = V10 & 65535;
        V10 = esi;
        edi = esi;
        V10 = eax;
        esi = A1c;
        V10 = V10 + esi;
        edi = V10;
        eax = L00000f14(edi, edi, eax);
        *HandleDataReceive = V14;
    }
L00000f25:
    esi = A1c + 30;
    V14 = esi;
    edi = A1c;
    edx = *(edi + 26) & 255;
    if(edx != 4) {
        if(edx == 7) {
            goto L00000fb0;
        }
    } else {
        eax = A1c;
        if(*(eax + 28) == 0) {
            esi = bx & 65535;
            edi = esi;
            V10 = esi;
            eax = SendLLDPingResponse(eax, edi, 1);
            goto L00001513;
        }
        if(dx != 256) {
            goto L00001513;
        }
        *HandleDataReceive = bx;
        eax = *(A24 + 4) & 255;
        V10 = eax;
        (save)eax;
        esi = bx & 65535;
        edi = esi;
        (save)HandleDataReceive;
        V10 = esi;
        (save)edi;
        eax = A1c;
        (save)eax;
        eax = L00000fa1();
        goto L00001513;
        esi = esi + HandleDataReceive;
L00000fb0:
        esi = A1c;
        edx = *(esi + 28) & 65535;
        if(edx != 1280) {
            > ? L00001010 : ;
            if(edx != 512) {
                > ? L00000ff0 : ;
                if(edx != 0) {
                    if(edx == 256) {
                        goto L000010c0;
                    }
                    goto L00001513;
                    if(edx == 768) {
                        goto L00001190;
                    }
                    if(edx == 1024) {
                        goto L000011e0;
                    }
                    goto L00001513;
                    esi = esi + HandleDataReceive;
                    if(edx == 2048) {
                        goto L00001310;
                    }
                    > ? L00001040 : ;
                    if(edx == 1536) {
                        goto L00001280;
                    }
                    if(edx == 1792) {
                        goto L000012e3;
                    }
                    goto L00001513;
                    esi = esi + HandleDataReceive;
                    if(edx == 2560) {
                        goto L00001424;
                    }
                    > ? L00001060 : ;
                    if(edx == LLDRxFragments) {
                        goto L000013c8;
                    }
                    goto L00001513;
                    if(edx == 2816) {
                        goto L00001450;
                    }
                    goto L00001513;
                }
                ecx = 4;
                edi = V14;
                eax = 0;
                asm("cld");
                asm("rep stosd");
                *edi = al;
                edi = edi + 1;
                ecx = 1;
                edi = V14;
                esi = HandleDataReceive;
                asm("cld");
                asm("rep movsd");
                *edi = *esi;
                edi = edi + 4;
                esi = esi + 4;
                *edi = *esi;
                edi = edi + 1;
                esi = esi + 1;
                edx = A1c + 37;
                ecx = 2;
                edi = edx;
                esi = HandleDataReceive;
                asm("cld");
                asm("rep movsd");
                *edi = *esi;
                edi = edi + 4;
                esi = esi + 4;
                eax = A1c;
                (save)eax;
                (save)32768;
                (save)17;
                goto L000014d1;
                esi = esi + HandleDataReceive;
L000010c0:
                esi = A1c;
                al = *HandleDataReceive;
                *(esi + 30) = al;
                esi = V14;
                al = *HandleDataReceive;
                *(esi + 1) = al;
                if(*HandleDataReceive != HandleDataReceive) {
                    *(esi + 2) = 1;
                    goto L00001138;
                    esi = esi + HandleDataReceive;
                }
                if(*HandleDataReceive != HandleDataReceive) {
                    edi = V14;
                    *(edi + 2) = 2;
                } else {
                    if(*HandleDataReceive != HandleDataReceive) {
                        if(*HandleDataReceive != HandleDataReceive) {
                            eax = V14;
                            *(eax + 2) = 3;
                            goto L00001138;
                        }
                        esi = V14;
                        *(esi + 2) = 4;
                        goto L00001138;
                        esi = esi + HandleDataReceive;
                    }
                    edi = V14;
                    *(edi + 2) = HandleDataReceive;
                }
L00001138:
                eax = A1c;
                (save)eax;
                (save)32769;
                (save)3;
                goto L000014d1;
                esi = esi + HandleDataReceive;
            }
            if(*HandleDataReceive != HandleDataReceive) {
                esi = A1c;
                *(esi + 30) = HandleDataReceive;
                (save)esi;
                (save)32770;
                (save)1;
                goto L000014d1;
            }
            edi = A1c;
            *(edi + 30) = 1;
            esi = V14;
            *(esi + 1) = *HandleDataReceive;
            (save)edi;
            (save)32770;
            goto L000014cf;
L00001190:
            edx = *HandleDataReceive >> 2 & 65535;
            edi = edx + edx * 4;
            eax = ((edx + edi * 8 << 5) - edx << 2) - edx >> 17;
            (save)( *HandleDataReceive & 65535) + ( *HandleDataReceive & 65535) * 4 + eax;
            esi = V14;
            (save)esi;
            eax = ConvertLongIntoBigEndian();
            edi = A1c;
            (save)edi;
            (save)32771;
            (save)4;
            goto L00001441;
L000011e0:
            ecx = 4;
            edi = V14;
            eax = 0;
            asm("cld");
            asm("rep stosd");
            *edi = eax;
            edi = edi + 4;
            eax = A1c;
            esi = *HandleDataReceive;
            *(eax + 30) = esi;
            edi = V14;
            eax = *L00000004;
            *(edi + 4) = eax;
            esi = *L00000008;
            *(edi + 8) = esi;
            edi = A1c;
            eax = *HandleDataReceive;
            *(edi + 42) = eax;
            *(edi + 46) = *L00000004;
            (save)edi;
            (save)32772;
            (save)18;
        } else {
            edi = V14;
            (save)edi;
            eax = *HandleDataReceive & 255;
            esi = eax;
            V10 = eax;
            (save)esi;
            (save)HandleDataReceive;
            eax = SetupMasterHistory();
            edx = eax;
            edi = A1c;
            (save)edi;
            eax = dx & 65535;
            esi = eax;
            (save)32773;
            V10 = eax;
            (save)esi;
            eax = SendManagementDataPkt();
            esp = esp + 24;
            goto L00001513;
            esi = esi + HandleDataReceive;
L00001280:
            eax = L00001281();
            edx = eax - *HandleDataReceive;
            edi = V14;
            eax = ConvertLongIntoBigEndian(edi, edx);
            esi = *HandleDataReceive;
            eax = A1c;
            edx = A1c + 34;
            *(eax + 34) = esi;
            edi = *L00000004;
            *(edx + 4) = edi;
            eax = *L00000008;
            *(edx + 8) = eax;
            esi = *L0000000C;
            *(edx + 12) = esi;
            edi = *L00000010;
            *(edx + 16) = edi;
            eax = A1c;
            (save)eax;
            (save)32774;
            (save)24;
            goto L000014d1;
L000012e3:
            ecx = 62;
            edi = V14;
            esi = HandleDataReceive;
            asm("cld");
            asm("rep movsd");
            *edi = *esi;
            edi = edi + 4;
            esi = esi + 4;
            *edi = *esi;
            edi = edi + 1;
            esi = esi + 1;
            (save)A1c;
            (save)32775;
            (save)251;
            goto L000014d1;
            esi = esi + HandleDataReceive;
L00001310:
            esi = *HandleDataReceive;
            (save)esi;
            edi = V14;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save) *HandleDataReceive;
            esi = A1c + 34;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save) *HandleDataReceive;
            esi = A1c + 38;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save) *HandleDataReceive;
            esi = A1c + 42;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            esp = esp + 32;
            (save) *HandleDataReceive;
            esi = A1c + 46;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save) *HandleDataReceive;
            esi = A1c + 50;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save) *HandleDataReceive;
            esi = A1c + 54;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save)A1c;
            (save)32776;
            (save)28;
            goto L00001417;
L000013c8:
            esi = *HandleDataReceive;
            (save)esi;
            edi = V14;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save) *HandleDataReceive;
            esi = A1c + 34;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            (save) *HandleDataReceive;
            esi = A1c + 38;
            V10 = esi;
            edi = esi;
            (save)edi;
            eax = ConvertLongIntoBigEndian();
            eax = A1c;
            (save)eax;
            (save)32777;
            (save)12;
L00001417:
            eax = SendManagementDataPkt();
            esp = esp + 36;
            goto L00001513;
L00001424:
            esi = *HandleDataReceive;
            (save)esi;
            (save)V14;
            eax = ConvertLongIntoBigEndian();
            eax = A1c;
            (save)eax;
            (save)32778;
            (save)8;
L00001441:
            eax = SendManagementDataPkt();
            esp = esp + 20;
            goto L00001513;
L00001450:
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            *HandleDataReceive = HandleDataReceive;
            eax = L000014b5();
            edx = eax;
            esi = A1c;
            *HandleDataReceive = edx;
            *(esi + 30) = HandleDataReceive;
            (save)esi;
            (save)32779;
L000014cf:
            (save)2;
        }
L000014d1:
        eax = SendManagementDataPkt();
        esp = esp + 12;
        goto L00001513;
        esi = esi + HandleDataReceive;
    }
    *HandleDataReceive = bx;
    eax = *(A24 + 4) & 255;
    V10 = eax;
    esi = bx & 65535;
    V10 = esi;
    eax = L00001505(A1c, esi, HandleDataReceive, V10);
    *HandleDataReceive = *HandleDataReceive + 1;
L00001513:
}

/*	Procedure: 0x0000151B - 0x0000151F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L0000151B()
{



    esi = esi + HandleDataReceive;
}

/*	Procedure: 0x00001520 - 0x00001614
 *	Argument size: 12
 *	Local size: 8
 *	Save regs size: 16
 */

SendManagementDataPkt(A1c, A20, A24)
/* unknown */ void  A1c;
/* unknown */ void  A20;
/* unknown */ void  A24;
{
	/* unknown */ void  ebx;
	/* unknown */ void  V10;
	/* unknown */ void  esi;
	/* unknown */ void  edi;
	/* unknown */ void  V16;



    esi = A24;
    V16 = A20;
    L0000153d();
    L00001546();
    eax = L0000154f(80, 7, 68, 7, 77, 7);
    ebx = *HandleDataReceive;
    if(ebx != 0) {
        *HandleDataReceive = *(ebx + 1568);
        eax = (bp & 65535) + 30;
        edi = ebx + 18;
        V10 = edi;
        ecx = eax >> 2;
        asm("cld");
        asm("rep movsd");
        if(!(al & 2)) {
            *edi = *esi;
            edi = edi + 4;
            esi = esi + 4;
        }
        if(!(al & 1)) {
            *edi = *esi;
            edi = edi + 1;
            esi = esi + 1;
        }
        eax = A1c + 30;
        *(ebx + 16) = ax;
        *(ebx + 10) = ax;
        ax = A1c + 16 >> 8;
        ecx = V10;
        *(ecx + 12) = al;
        *(ecx + 13) = dl;
        *(ebx + 12) = ebx + 1572;
        *(ebx + 1572) = HandleDataReceive;
        edx = ebx + 24;
        *(ebx + 18) = *(ebx + 24);
        *(ecx + 4) = *(edx + 4);
        *(ebx + 24) = *HandleDataReceive;
        *(edx + 4) = *L00000004;
        *(ecx + 28) = V16 >> 8;
        *(V10 + 29) = V16;
        eax = L00001606(ebx + 4);
    }
}

/*	Procedure: 0x00001615 - 0x0000161F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00001615()
{



    esi = esi + HandleDataReceive;
    edi = edi + HandleDataReceive;
}

/*	Procedure: 0x00001620 - 0x00001727
 *	Argument size: 12
 *	Local size: 28
 *	Save regs size: 16
 */

SetupMasterHistory(A30, A34, A38)
/* unknown */ void  A30;
/* unknown */ void  A34;
/* unknown */ void  A38;
{
	/* unknown */ void  ebx;
	/* unknown */ void  V10;
	/* unknown */ void  esi;
	/* unknown */ void  edi;
	/* unknown */ void  V14;
	/* unknown */ void  V18;
	/* unknown */ void  V1f;
	/* unknown */ void  V20;
	/* unknown */ void  V27;
	/* unknown */ void  V28;
	/* unknown */ void  V2b;



    V2b = A34;
    edx = A34 & 255;
    ecx = edx + (edx + edx * 4) * 2 + edx + (edx + edx * 4) * 2 + 1;
    V28 = cx;
    if(A34 != 0) {
        esi = A38;
        V10 = esi;
        ecx = (cx & 65535) >> 2;
        edi = esi;
        eax = 0;
        asm("cld");
        asm("rep stosd");
        if(!(dl & 2)) {
            *edi = eax;
            edi = edi + 4;
        }
        if(!(dl & 1)) {
            *edi = A34;
            edi = edi + 1;
        }
        V20 = L00001674();
        V27 = HandleDataReceive;
        if(V27 < V2b) {
            V1f = V2b;
            V1f = V1f - 1;
            esi = esi + HandleDataReceive;
            do {
                eax = V1f & 255;
                V18 = eax;
                esi = V18 + V18 * 2 << 3;
                V18 = esi;
                esi = V18 + A30;
                V14 = esi;
                ecx = 2;
                edi = V10;
                asm("cld");
                asm("rep movsd");
                *edi = *esi;
                edi = edi + 4;
                esi = esi + 4;
                *edi = *esi;
                edi = edi + 1;
                esi = esi + 1;
                V10 = V10 + 12;
                eax = V14;
                esi = V10;
                *esi = *(eax + 11);
                *(esi + 4) = *(eax + 15);
                esi = esi + 6;
                V10 = esi;
                ConvertLongIntoBigEndian(esi, V20 - *(A30 + V18 + 20));
                V10 = esi + 4;
                V1f = V1f - 1;
                V27 = V27 + 1;
            } while(V27 < V2b);
        }
    }
    return(V28 & 65535);
}

/*	Procedure: 0x00001728 - 0x0000172F
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00001728()
{



    esi = esi + HandleDataReceive;
}

/*	Procedure: 0x00001730 - 0x00001752
 *	Argument size: 8
 *	Local size: 0
 *	Save regs size: 0
 */

ConvertLongIntoBigEndian(A4, A8)
/* unknown */ void  A4;
/* unknown */ void  A8;
{



    eax = edx >> 24;
    *A4 = al;
    eax = edx >> 16;
    *(A4 + 1) = al;
    *(A4 + 2) = edx >> 8;
    *(A4 + 3) = A8;
    return(*(A4 + 2));
}

extern /* addr: 00001753 */  /*	Procedure: 0x00001753 - 0x00000000
 *	Argument size: 0
 *	Local size: 0
 *	Save regs size: 0
 */

L00001753()
/* address  size  */
/* 0x00000000       0 */ /* unknown */ void 	HandleDataReceive;
/* 0x00000000       0 */ /* unknown */ void 	LLDRx;
/* 0x00000000       0 */ /* unknown */ void 	OutChar;
/* 0x00000000       0 */ /* unknown */ void 	LLDMSTAFlag;
/* 0x00000000       0 */ /* unknown */ void 	LLDNoRepeatingFlag;
/* 0x00000000       0 */ /* unknown */ void 	LLDNodeAddress;
/* 0x00000000       0 */ /* unknown */ void 	LLDGetEntry;
/* 0x00000000       0 */ /* unknown */ void 	NodeTable;
/* 0x00000000       0 */ /* unknown */ void 	LLDBridgeFlag;
/* 0x00000000       0 */ /* unknown */ void 	LLSGetCurrentTime;
/* 0x00000000       0 */ /* unknown */ void 	IsProximPacket;
/* 0x00000000       0 */ /* unknown */ void 	FramesRx;
/* 0x00000000       0 */ /* unknown */ void 	LLSReceiveLookAhead;
/* 0x00000000       0 */ /* unknown */ void 	LLDRxLookAhead;
/* 0x00000000       0 */ /* unknown */ void 	LLDBadCopyLen;
/* 0x00000000       0 */ /* unknown */ void 	OutHex;
/* 0x00000000       0 */ /* unknown */ void 	LLDTransferMode;
/* 0x00000000       0 */ /* unknown */ void 	GetRxData;
/* 0x00000000       0 */ /* unknown */ void 	FramesRxDuplicate;
/* 0x00000000       0 */ /* unknown */ void 	FramesRxFrag;
/* 0x00000000       0 */ /* unknown */ void 	LLDTxMode;
/* 0x00000000       0 */ /* unknown */ void 	LLDPacketizeSend;
/* 0x00000000       0 */ /* unknown */ void 	FreeTXBuffer;
/* 0x00000000       0 */ /* unknown */ void 	LLDSend;
/* 0x00000000       0 */ /* unknown */ void 	LLSPingReceiveLookAhead;
/* 0x00000000       0 */ /* unknown */ void 	LLDROMVersion;
/* 0x00000000       0 */ /* unknown */ void 	DriverVersionString;
/* 0x00000000       0 */ /* unknown */ void 	LLDDomain;
/* 0x00000000       0 */ /* unknown */ void 	LLDPeerToPeerFlag;
/* 0x00000000       0 */ /* unknown */ void 	LLDOEM;
/* 0x00000000       0 */ /* unknown */ void 	LLDMicroISA;
/* 0x00000000       0 */ /* unknown */ void 	LLDPCMCIA;
/* 0x00000000       0 */ /* unknown */ void 	LLDOnePieceFlag;
/* 0x00000000       0 */ /* unknown */ void 	LLDRoamingFlag;
/* 0x00000000       0 */ /* unknown */ void 	LLDRoamConfiguration;
/* 0x00000000       0 */ /* unknown */ void 	LLDInactivityTimeOut;
/* 0x00000000       0 */ /* unknown */ void 	LLDTicksToSniff;
/* 0x00000000       0 */ /* unknown */ void 	LLDMSTASyncName;
/* 0x00000000       0 */ /* unknown */ void 	LLDMSTAAddr;
/* 0x00000000       0 */ /* unknown */ void 	NextMaster;
/* 0x00000000       0 */ /* unknown */ void 	LLSGetCurrentTimeLONG;
/* 0x00000000       0 */ /* unknown */ void 	ResetStatisticsTime;
/* 0x00000000       0 */ /* unknown */ void 	StationName;
/* 0x00000000       0 */ /* unknown */ void 	NotesBuffer;
/* 0x00000000       0 */ /* unknown */ void 	TotalTxPackets;
/* 0x00000000       0 */ /* unknown */ void 	FramesXmit;
/* 0x00000000       0 */ /* unknown */ void 	FramesCTSError;
/* 0x00000000       0 */ /* unknown */ void 	FramesACKError;
/* 0x00000000       0 */ /* unknown */ void 	FramesXmitBFSK;
/* 0x00000000       0 */ /* unknown */ void 	FramesXmitQFSK;
/* 0x00000000       0 */ /* unknown */ void 	FramesXmitFrag;
/* 0x00000000       0 */ /* unknown */ void 	LLDErrResetCnt;
/* 0x00000000       0 */ /* unknown */ void 	LLDUnknownProximPkt;
/* 0x000002a0    1296 */ /* unknown */ void 	LLDReceive;
/* 0x000007b0      64 */ /* unknown */ void 	LLDRawReceive;
/* 0x000007f0     272 */ /* unknown */ void 	LLDDuplicateDetection;
/* 0x00000900     544 */ /* unknown */ void 	LLDRxFragments;
/* 0x00000b20     368 */ /* unknown */ void 	LLDRepeat;
/* 0x00000c90     256 */ /* unknown */ void 	SendLLDPingResponse;
/* 0x00000d90      64 */ /* unknown */ void 	CheckRoamNotify;
/* 0x00000dd0     208 */ /* unknown */ void 	CheckRxBuffTimeOut;
/* 0x00000ea0    1664 */ /* unknown */ void 	ProcessProximPkt;
/* 0x00001520     256 */ /* unknown */ void 	SendManagementDataPkt;
/* 0x00001620     272 */ /* unknown */ void 	SetupMasterHistory;
/* 0x00001730       0 */ /* unknown */ void 	ConvertLongIntoBigEndian;
#if 0 /* auxiliary information */
# Current option values:
option: +asmflush
option: -compactcalls
option: +compactexprs
option: +compactifs
option: +compset
option: -dfoproc
option: -disasmonly
option: -displaylabels
option: +doblocks
option: +docase
option: +dofor
option: +doifs
option: +dointrinsics
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: +dumpdoms
option: -dumpsblocks
option: -dumpsets
option: -dumpsizes
option: -dumpstmtid
option: +fatcase
option: -flag16
option: +fullscreen
option: -genpattern
option: -help
option: -hexconst
option: -html
option: +insertlabels
option: -int16
option: +int32
option: -interactive
option: +locals
option: -nohtmltabs
option: -nostackoffs
option: -objdump
option: -okclone
option: -outprocs
option: -outrefs
option: -overrule
option: +rdonly
option: -showblocks
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