// File: ctSkennerton[P]fxtract/util/./railgun7s.c
// Function: Railgun7s
char *
Railgun7s(char *pbTarget, int cbTarget, char *pbPattern, int cbPattern)

{
    char   *pbTargetMax = pbTarget + cbTarget;
    register uint32_t ulHashPattern;
    register uint32_t ulHashTarget;
    signed long count;
    signed long countSTATIC;

    unsigned char SINGLET;
    uint32_t Quadruplet2nd;
    uint32_t Quadruplet3rd;
    uint32_t Quadruplet4th;

    uint32_t AdvanceHopperGrass;

    long    i;                  //BMH needed
    int     a, j;
    unsigned char bm_Horspool_Order2[256 * 256];    // BMHSS(Elsiane) needed, 'char' limits patterns to 255, if 'long' then table becomes 256KB, grrr.
    uint32_t Gulliver;          // or unsigned char or unsigned short

    unsigned char bm_Hasherezade_HASH[1 << (HashTableSizeSekirei - 3)];
    uint32_t hash32;
    uint32_t hash32B;
    uint32_t hash32C;

    if (cbPattern > cbTarget)
        return (NULL);

    if (cbPattern < 4) {

        pbTarget = pbTarget + cbPattern;
        ulHashPattern =
            ((*(char *)(pbPattern)) << 8) + *(pbPattern + (cbPattern - 1));
        if (cbPattern == 3) {
            for (;;) {
                if ((int)ulHashPattern ==
                    ((*(char *)(pbTarget - 3)) << 8) + *(pbTarget - 1)) {
                    if (*(char *)(pbPattern + 1) == *(char *)(pbTarget - 2))
                        return ((pbTarget - 3));
                }
                if ((char)(ulHashPattern >> 8) != *(pbTarget - 2)) {
                    pbTarget++;
                    if ((char)(ulHashPattern >> 8) != *(pbTarget - 2))
                        pbTarget++;
                }
                pbTarget++;
                if (pbTarget > pbTargetMax)
                    return (NULL);
            }
        } else {
        }
        for (;;) {
            if ((int)ulHashPattern == ((*(char *)(pbTarget - 2)) << 8) + *(pbTarget - 1))
                return ((pbTarget - 2));
            if ((char)(ulHashPattern >> 8) != *(pbTarget - 1))
                pbTarget++;
            pbTarget++;
            if (pbTarget > pbTargetMax)
                return (NULL);
        }

    } else {
        if (cbTarget < HaystackThresholdSekirei) {  // This value is arbitrary (don't know how exactly), it ensures (at least must) better performance than 'Boyer_Moore_Horspool'.

            pbTarget = pbTarget + cbPattern;
            ulHashPattern = *(uint32_t *) (pbPattern);
            SINGLET = ulHashPattern & 0xFF;
            Quadruplet2nd = SINGLET << 8;
            Quadruplet3rd = SINGLET << 16;
            Quadruplet4th = SINGLET << 24;
            for (;;) {
                AdvanceHopperGrass = 0;
                ulHashTarget = *(uint32_t *) (pbTarget - cbPattern);
                if (ulHashPattern == ulHashTarget) {    // Three unnecessary comparisons here, but 'AdvanceHopperGrass' must be calculated - it has a higher priority.
                    count = cbPattern - 1;
                    while (count &&
                           *(char *)(pbPattern + (cbPattern - count)) ==
                           *(char *)(pbTarget - count)) {
                        if (cbPattern - 1 == AdvanceHopperGrass + count &&
                            SINGLET != *(char *)(pbTarget - count))
                            AdvanceHopperGrass++;
                        count--;
                    }
                    if (count == 0)
                        return ((pbTarget - cbPattern));
                } else {        // The goal here: to avoid memory accesses by stressing the registers.
                    if (Quadruplet2nd != (ulHashTarget & 0x0000FF00)) {
                        AdvanceHopperGrass++;
                        if (Quadruplet3rd != (ulHashTarget & 0x00FF0000)) {
                            AdvanceHopperGrass++;
                            if (Quadruplet4th != (ulHashTarget & 0xFF000000))
                                AdvanceHopperGrass++;
                        }
                    }
                }
                AdvanceHopperGrass++;
                pbTarget = pbTarget + AdvanceHopperGrass;
                if (pbTarget > pbTargetMax)
                    return (NULL);
            }

        } else {                //if (cbTarget<HaystackThresholdSekirei)

            if (cbPattern <= NeedleThresholdBIGSekirei) {

                countSTATIC = cbPattern - 2 - 2;
                ulHashPattern = *(uint32_t *) (pbPattern);  // First four bytes
                //ulHashTarget = *(unsigned short *)(pbPattern+cbPattern-1-1); // Last two bytes
                i = 0;
                //for (a=0; a < 256*256; a++) {bm_Horspool_Order2[a]= cbPattern-1;} // cbPattern-(Order-1) for Horspool; 'memset' if not optimized
                //for (j=0; j < cbPattern-1; j++) bm_Horspool_Order2[*(unsigned short *)(pbPattern+j)]=j; // Rightmost appearance/position is needed
                for (a = 0; a < 256 * 256; a++) {
                    bm_Horspool_Order2[a] = 0;
                }
                for (j = 0; j < cbPattern - 1; j++)
                    bm_Horspool_Order2[*(unsigned short *)(pbPattern + j)] =
                        1;
                while (i <= cbTarget - cbPattern) {
                    Gulliver = 1;
                    if (bm_Horspool_Order2
                        [*(unsigned short *)&pbTarget[i + cbPattern - 1 - 1]]
                        != 0) {
                        //if ( Gulliver == 1 ) { // Means the Building-Block order 2 is found somewhere i.e. NO MAXIMUM SKIP
                        if (*(uint32_t *) & pbTarget[i] == ulHashPattern) {
                            count = countSTATIC;    // Last two chars already matched, to be fixed with -2
                            while (count != 0 &&
                                   *(char *)(pbPattern +
                                             (countSTATIC - count) + 4) ==
                                   *(char *)(&pbTarget[i] +
                                             (countSTATIC - count) + 4))
                                count--;
                            if (count == 0)
                                return (pbTarget + i);
                        }
                        //}
                    } else
                        Gulliver = cbPattern - (2 - 1);
                    i = i + Gulliver;
                    //GlobalI++; // Comment it, it is only for stats.
                }
                return (NULL);

            } else {            // if ( cbPattern<=NeedleThresholdBIGSekirei )
// MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() [
                countSTATIC = cbPattern - 2 - 2;

                ulHashPattern = *(uint32_t *) (pbPattern);  // First four bytes
                //ulHashTarget = *(unsigned short *)(pbPattern+cbPattern-1-1); // Last two bytes

                i = 0;

                for (a = 0; a < 1 << (HashTableSizeSekirei - 3); a++) {
                    bm_Hasherezade_HASH[a] = 0;
                }               // to-do: 'memset' if not optimized
                // cbPattern - Order + 1 i.e. number of BBs for 11 'fastest fox' 11-8+1=4: 'fastest ', 'astest f', 'stest fo', 'test fox'
                for (j = 0; j < cbPattern - 12 + 1; j++) {
                    hash32 =
                        (2166136261 ^ *(uint32_t *) (pbPattern + j + 0)) *
                        709607;
                    hash32B =
                        (2166136261 ^ *(uint32_t *) (pbPattern + j + 4)) *
                        709607;
                    hash32C =
                        (2166136261 ^ *(uint32_t *) (pbPattern + j + 8)) *
                        709607;
                    hash32 = (hash32 ^ _rotl_KAZE(hash32C, 5)) * 709607;
                    hash32 = (hash32 ^ _rotl_KAZE(hash32B, 5)) * 709607;
                    hash32 =
                        (hash32 ^ (hash32 >> 16)) &
                        ((1 << (HashTableSizeSekirei)) - 1);
                    bm_Hasherezade_HASH[hash32 >> 3] =
                        bm_Hasherezade_HASH[hash32 >> 3] | (1 <<
                                                            (hash32 & 0x7));
                }

                while (i <= cbTarget - cbPattern) {
                    Gulliver = 1;   // Assume minimal jump as initial value.
                    // The goal: to jump when the rightmost 8bytes (Order 8 Horspool) of window do not look like any of Needle prefixes i.e. are not to be found. This maximum jump equals cbPattern-(Order-1) or 11-(8-1)=4 for 'fastest fox' - a small one but for Needle 31 bytes the jump equals 31-(8-1)=24
                    //GlobalHashSectionExecution++; // Comment it, it is only for stats.
                    hash32 =
                        (2166136261 ^
                         *(uint32_t *) (pbTarget + i + cbPattern - 12 +
                                        0)) * 709607;
                    hash32B =
                        (2166136261 ^
                         *(uint32_t *) (pbTarget + i + cbPattern - 12 +
                                        4)) * 709607;
                    hash32C =
                        (2166136261 ^
                         *(uint32_t *) (pbTarget + i + cbPattern - 12 +
                                        8)) * 709607;
                    hash32 = (hash32 ^ _rotl_KAZE(hash32C, 5)) * 709607;
                    hash32 = (hash32 ^ _rotl_KAZE(hash32B, 5)) * 709607;
                    hash32 =
                        (hash32 ^ (hash32 >> 16)) &
                        ((1 << (HashTableSizeSekirei)) - 1);
                    if ((bm_Hasherezade_HASH[hash32 >> 3] &
                         (1 << (hash32 & 0x7))) == 0)
                        Gulliver = cbPattern - (12 - 1);

                    if (Gulliver == 1) {    // Means the Building-Block order 8/12 is found somewhere i.e. NO MAXIMUM SKIP
                        if (*(uint32_t *) & pbTarget[i] == ulHashPattern) {
                            count = countSTATIC;
                            while (count != 0 &&
                                   *(char *)(pbPattern +
                                             (countSTATIC - count) + 4) ==
                                   *(char *)(&pbTarget[i] +
                                             (countSTATIC - count) + 4))
                                count--;
                            if (count == 0)
                                return (pbTarget + i);
                        }
                    }
                    i = i + Gulliver;
                    //GlobalI++; // Comment it, it is only for stats.
                }               // while (i <= cbTarget-cbPattern)
                return (NULL);
// MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() MEMMEM() ]
            }                   // if ( cbPattern<=NeedleThresholdBIGSekirei )
        }                       //if (cbTarget<HaystackThresholdSekirei)
    }                           //if ( cbPattern<4 )
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x12010, %rsp          # imm = 0x12010
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x5acd
movq $0x0, -0x8(%rbp)
jmp 0x62f7
cmpl $0x4, -0x24(%rbp)
jge 0x5c38
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x3, -0x24(%rbp)
jne 0x5bc1
jmp 0x5b12
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl -0x3(%rcx), %ecx
shll $0x8, %ecx
movq -0x10(%rbp), %rdx
movsbl -0x1(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jne 0x5b55
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
movq -0x10(%rbp), %rcx
movsbl -0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x5b53
movq -0x10(%rbp), %rax
addq $-0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x62f7
jmp 0x5b55
movl -0x34(%rbp), %eax
shrl $0x8, %eax
movsbl %al, %eax
movq -0x10(%rbp), %rcx
movsbl -0x2(%rcx), %ecx
cmpl %ecx, %eax
je 0x5b99
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %eax
shrl $0x8, %eax
movsbl %al, %eax
movq -0x10(%rbp), %rcx
movsbl -0x2(%rcx), %ecx
cmpl %ecx, %eax
je 0x5b97
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5b99
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x5bbc
movq $0x0, -0x8(%rbp)
jmp 0x62f7
jmp 0x5b12
jmp 0x5bc3
jmp 0x5bc5
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl -0x2(%rcx), %ecx
shll $0x8, %ecx
movq -0x10(%rbp), %rdx
movsbl -0x1(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jne 0x5bf2
movq -0x10(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x62f7
movl -0x34(%rbp), %eax
shrl $0x8, %eax
movsbl %al, %eax
movq -0x10(%rbp), %rcx
movsbl -0x1(%rcx), %ecx
cmpl %ecx, %eax
je 0x5c13
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x5c36
movq $0x0, -0x8(%rbp)
jmp 0x62f7
jmp 0x5bc5
cmpl $0x3c1, -0x14(%rbp)     # imm = 0x3C1
jge 0x5de6
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0xff, %eax
movb %al, -0x49(%rbp)
movzbl -0x49(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x50(%rbp)
movzbl -0x49(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x54(%rbp)
movzbl -0x49(%rbp), %eax
shll $0x18, %eax
movl %eax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jne 0x5d62
movl -0x24(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x40(%rbp)
movb %al, -0x1208d(%rbp)
je 0x5cf0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
subq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
subq -0x40(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1208d(%rbp)
movb -0x1208d(%rbp), %al
testb $0x1, %al
jne 0x5cfc
jmp 0x5d40
movl -0x24(%rbp), %eax
subl $0x1, %eax
cltq
movl -0x5c(%rbp), %ecx
addq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5d2f
movzbl -0x49(%rbp), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
subq -0x40(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x5d2f
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x5cb8
cmpq $0x0, -0x40(%rbp)
jne 0x5d60
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x62f7
jmp 0x5db3
movl -0x50(%rbp), %eax
movl -0x38(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
cmpl %ecx, %eax
je 0x5db1
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movl -0x54(%rbp), %eax
movl -0x38(%rbp), %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
cmpl %ecx, %eax
je 0x5daf
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movl -0x58(%rbp), %eax
movl -0x38(%rbp), %ecx
andl $0xff000000, %ecx       # imm = 0xFF000000
cmpl %ecx, %eax
je 0x5dad
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x5daf
jmp 0x5db1
jmp 0x5db3
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x5de1
movq $0x0, -0x8(%rbp)
jmp 0x62f7
jmp 0x5c86
cmpl $0x34, -0x24(%rbp)
jg 0x5f75
movl -0x24(%rbp), %eax
subl $0x2, %eax
subl $0x2, %eax
cltq
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
cmpl $0x10000, -0x6c(%rbp)   # imm = 0x10000
jge 0x5e37
movslq -0x6c(%rbp), %rax
movb $0x0, -0x10070(%rbp,%rax)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x5e17
movl $0x0, -0x70(%rbp)
movl -0x70(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5e6a
movq -0x20(%rbp), %rax
movslq -0x70(%rbp), %rcx
movzwl (%rax,%rcx), %eax
movb $0x1, -0x10070(%rbp,%rax)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x5e3e
jmp 0x5e6c
movq -0x68(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jg 0x5f68
movl $0x1, -0x10074(%rbp)
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
movslq -0x24(%rbp), %rdx
addq %rdx, %rcx
subq $0x1, %rcx
subq $0x1, %rcx
movzwl (%rax,%rcx), %eax
movzbl -0x10070(%rbp,%rax), %eax
cmpl $0x0, %eax
je 0x5f46
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
movl (%rax,%rcx), %eax
cmpl -0x34(%rbp), %eax
jne 0x5f44
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x40(%rbp)
movb %al, -0x1208e(%rbp)
je 0x5f10
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
subq -0x40(%rbp), %rcx
movsbl 0x4(%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
addq -0x68(%rbp), %rcx
movq -0x48(%rbp), %rdx
subq -0x40(%rbp), %rdx
movsbl 0x4(%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1208e(%rbp)
movb -0x1208e(%rbp), %al
testb $0x1, %al
jne 0x5f1c
jmp 0x5f2a
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x5ed0
cmpq $0x0, -0x40(%rbp)
jne 0x5f42
movq -0x10(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x62f7
jmp 0x5f44
jmp 0x5f52
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10074(%rbp)
movq -0x68(%rbp), %rax
movl -0x10074(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
jmp 0x5e6c
movq $0x0, -0x8(%rbp)
jmp 0x62f7
movl -0x24(%rbp), %eax
subl $0x2, %eax
subl $0x2, %eax
cltq
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
cmpl $0x2000, -0x6c(%rbp)    # imm = 0x2000
jge 0x5fbc
movslq -0x6c(%rbp), %rax
movb $0x0, -0x12080(%rbp,%rax)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x5f9c
movl $0x0, -0x70(%rbp)
movl -0x70(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0xc, %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x60fd
movq -0x20(%rbp), %rax
movslq -0x70(%rbp), %rcx
movl (%rax,%rcx), %eax
movabsq $0x811c9dc5, %rcx       # imm = 0x811C9DC5
xorq %rcx, %rax
imulq $0xad3e7, %rax, %rax    # imm = 0xAD3E7
movl %eax, -0x12084(%rbp)
movq -0x20(%rbp), %rax
movslq -0x70(%rbp), %rcx
movl 0x4(%rax,%rcx), %eax
movabsq $0x811c9dc5, %rcx       # imm = 0x811C9DC5
xorq %rcx, %rax
imulq $0xad3e7, %rax, %rax    # imm = 0xAD3E7
movl %eax, -0x12088(%rbp)
movq -0x20(%rbp), %rax
movslq -0x70(%rbp), %rcx
movl 0x8(%rax,%rcx), %eax
movabsq $0x811c9dc5, %rcx       # imm = 0x811C9DC5
xorq %rcx, %rax
imulq $0xad3e7, %rax, %rax    # imm = 0xAD3E7
movl %eax, -0x1208c(%rbp)
movl -0x12084(%rbp), %eax
movl -0x1208c(%rbp), %ecx
shll $0x5, %ecx
movl -0x1208c(%rbp), %edx
shrl $0x1b, %edx
orl %edx, %ecx
xorl %ecx, %eax
imull $0xad3e7, %eax, %eax    # imm = 0xAD3E7
movl %eax, -0x12084(%rbp)
movl -0x12084(%rbp), %eax
movl -0x12088(%rbp), %ecx
shll $0x5, %ecx
movl -0x12088(%rbp), %edx
shrl $0x1b, %edx
orl %edx, %ecx
xorl %ecx, %eax
imull $0xad3e7, %eax, %eax    # imm = 0xAD3E7
movl %eax, -0x12084(%rbp)
movl -0x12084(%rbp), %eax
movl -0x12084(%rbp), %ecx
shrl $0x10, %ecx
xorl %ecx, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x12084(%rbp)
movl -0x12084(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
movzbl -0x12080(%rbp,%rax), %eax
movl -0x12084(%rbp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movb %al, %cl
movl -0x12084(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
movb %cl, -0x12080(%rbp,%rax)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x5fc3
jmp 0x60ff
movq -0x68(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jg 0x62ef
movl $0x1, -0x10074(%rbp)
movq -0x10(%rbp), %rax
addq -0x68(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl -0xc(%rax,%rcx), %eax
movabsq $0x811c9dc5, %rcx       # imm = 0x811C9DC5
xorq %rcx, %rax
imulq $0xad3e7, %rax, %rax    # imm = 0xAD3E7
movl %eax, -0x12084(%rbp)
movq -0x10(%rbp), %rax
addq -0x68(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl -0x8(%rax,%rcx), %eax
movabsq $0x811c9dc5, %rcx       # imm = 0x811C9DC5
xorq %rcx, %rax
imulq $0xad3e7, %rax, %rax    # imm = 0xAD3E7
movl %eax, -0x12088(%rbp)
movq -0x10(%rbp), %rax
addq -0x68(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl -0x4(%rax,%rcx), %eax
movabsq $0x811c9dc5, %rcx       # imm = 0x811C9DC5
xorq %rcx, %rax
imulq $0xad3e7, %rax, %rax    # imm = 0xAD3E7
movl %eax, -0x1208c(%rbp)
movl -0x12084(%rbp), %eax
movl -0x1208c(%rbp), %ecx
shll $0x5, %ecx
movl -0x1208c(%rbp), %edx
shrl $0x1b, %edx
orl %edx, %ecx
xorl %ecx, %eax
imull $0xad3e7, %eax, %eax    # imm = 0xAD3E7
movl %eax, -0x12084(%rbp)
movl -0x12084(%rbp), %eax
movl -0x12088(%rbp), %ecx
shll $0x5, %ecx
movl -0x12088(%rbp), %edx
shrl $0x1b, %edx
orl %edx, %ecx
xorl %ecx, %eax
imull $0xad3e7, %eax, %eax    # imm = 0xAD3E7
movl %eax, -0x12084(%rbp)
movl -0x12084(%rbp), %eax
movl -0x12084(%rbp), %ecx
shrl $0x10, %ecx
xorl %ecx, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x12084(%rbp)
movl -0x12084(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
movzbl -0x12080(%rbp,%rax), %eax
movl -0x12084(%rbp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x6241
movl -0x24(%rbp), %eax
subl $0xb, %eax
movl %eax, -0x10074(%rbp)
cmpl $0x1, -0x10074(%rbp)
jne 0x62d9
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
movl (%rax,%rcx), %eax
cmpl -0x34(%rbp), %eax
jne 0x62d7
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x40(%rbp)
movb %al, -0x1208f(%rbp)
je 0x62a6
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
subq -0x40(%rbp), %rcx
movsbl 0x4(%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
addq -0x68(%rbp), %rcx
movq -0x48(%rbp), %rdx
subq -0x40(%rbp), %rdx
movsbl 0x4(%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1208f(%rbp)
movb -0x1208f(%rbp), %al
testb $0x1, %al
jne 0x62b2
jmp 0x62c0
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x6266
cmpq $0x0, -0x40(%rbp)
jne 0x62d5
movq -0x10(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x62f7
jmp 0x62d7
jmp 0x62d9
movq -0x68(%rbp), %rax
movl -0x10074(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
jmp 0x60ff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x12010, %rsp          # imm = 0x12010
popq %rbp
retq
nopw %cs:(%rax,%rax)