How can I debug and correctly implement a paper-based PKZIP key derivation algorithm in C?

I am working on optimizing an attack on PKZIP by reducing computational workload. PKZIP updates its internal state using the following operations:

CCopied
key0[i] = key0[i-1] >> 8 ^ crctab[key0[i-1] & 0xFF ^ plaintext[i]];
key1[i] = (key1[i-1] + (key0[i] & 0xFF)) * Const + 1;
key2[i] = key2[i-1] >> 8 ^ crctab[key2[i-1] & 0xFF ^ (key1[i] >> 24)];

and encrypts plaintext into ciphertext as follows:

CCopied
tmp = (key2[i] | 3) & 0xFFFF; // notice: makes the last 16 bits of key2 odd
key3[i] = ((tmp * (tmp ^ 1)) >> 8) & 0xFF; // notice: this is ((x**2)-x)//256 mod 256 or (x*(x + or - 1))//256 mod 256
ciphertext[i] = plaintext[i] ^ key3[i];

Programs like pkcrak use key3[i] and key3[i-1] to generate 2**22 possible key2 values per position, which is computationally expensive. I discovered that using three consecutive plaintext and ciphertext values allows derivation of three consecutive key3 values. However, since each key3 value has 256 possible last 16-bit candidates, identifying the link between consecutive key3 values is crucial. This led me to this Python prototype that validates my approach:

PYTHONCopied
import math
n = int(65536)

x = 0xc90b  # this is  key2[i-1] | 3
y = 0x2f17  # this is key2[i] | 3

a = ((x * x) - x) % n  # we haven't divided this by 256 for simplicity
b = ((y * y) - y) % n  # so the result of a ^ b is 16 bit or simply (e << 8)
e = (a ^ b) & 0xFF00

# EQUATION
'''
square root of (((x**2) - x) % n xor (256 * e)) == square root of (((y**2) - y) % n)
meaning given key3[i] and key3[i-1] we can get e by key3[i-1] xor key3[i]
And since there are only 64 odd last 16-bit values of key2 for each position, the above equation will yield a corresponding odd value for y
'''

i = round(math.sqrt((((x * x) - x) % n ^ e)))
j = round(math.sqrt(((y * y) - y) % n))

print(hex(a))
print(hex(b))
print(hex(e))
print(hex(i))
print(hex(j))

This Python code works perfectly and supports my theory. I then translated it into C:

CCopied
#include <time.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

#define CRCPOLY 0xedb88320
#define CONSTx      0x08088405U /* 134775813 */
#define MSB(x)          (((x) >> 24) & 0xFF)
#define MSBMASK         0xFF000000U
#define CRC32(x, c)  (((x) >> 8) ^ crctab[((x) ^ (c)) & 0xff])

uint32_t crctab[256];

const uint8_t plain[8] = {
    0x64, 0x14, 0x9A, 0xC7, 0xB2, 0x96, 0xC0, 0x15  
};
uint8_t cipher[8] = {
    
};

uint8_t key3[8] = {
    
};

uint32_t k0 = 0x12345678, t0;
uint32_t k1 = 0x23456789, t1;
uint32_t k2 = 0x34567890, t2;

static void mkCrcTab() {
    unsigned int i, j, c;
    for (i = 0; i < 256; i++) {
        c = i;
        for (j = 0; j < 8; j++)
            if (c & 1)
                c = (c >> 1) ^ CRCPOLY;
            else
                c = (c >> 1);
        crctab[i] = c;
    }
}

int main() {
    mkCrcTab();

    uint8_t pw[10] = {
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00
    };

    uint32_t ky0 = k0;  // FNV offset basis for 32-bit
    uint32_t ky1 = k1;  // FNV prime for 32-bit
    uint32_t ky2 = k2;
    uint16_t tmp;
    uint8_t bt;

    for (int i = 0; i < 10; i++) {
        ky0 = CRC32(ky0, pw[i]);
        ky1 = (k1 + (ky0 & 0xff)) * CONSTx + 1;
        ky2 = CRC32(ky2, MSB(ky1));
        printf("%08X %08X %08X\n", ky0, ky1, ky2);
    }
    t0 = ky0;
    t1 = ky1;
    t2 = ky2;
    printf("===================================\n");
    for (int i = 0; i < 8; i++) {
        ky0 = CRC32(ky0, plain[i]);
        ky1 = (k1 + (ky0 & 0xff)) * CONSTx + 1;
        ky2 = CRC32(ky2, MSB(ky1));
        printf("%08X %08X %08X\n", ky0, ky1, ky2);
        tmp = ky2 | 3;
        bt = ((tmp * (tmp ^ 1)) >> 8) & 0xFF;
        cipher[i] = plain[i] ^ bt;
        key3[i] = bt;
    }
    printf("===================================\n");
    printf("plain : ");
    for (int i = 0; i < 8; i++) {
        printf("%02X ", plain[i]);
    }
    printf("\n");
    printf("cipher : ");
    for (int i = 0; i < 8; i++) {
        printf("%02X ", cipher[i]);
    }
    printf("\n");
    printf("key3 : ");
    for (int i = 0; i < 8; i++) {
        printf("%02X ", key3[i]);
    }
    printf("\n");
    printf("===================================\n");
    return 0;
}

This C code encrypts an 8-byte plaintext into an 8-byte ciphertext using keys derived from the password "1234567890". However, when I verify whether the key2 candidate found for position 4 appears in the list generated by the algorithm, the value is incorrect. Now I'm uncertain whether the issue is due to my C implementation or a misinterpretation of the algorithm itself.

Thank you.