// x86 Subset Assembler - Tests
//-----------------------------------------------------------------------------
// Copyright (C) 2017 Jeffrey L. Overbey.  Use of this source code is governed
// by a BSD-style license posted at http://blog.jeff.over.bz/license/

#include "x86asm.h"
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

uint8_t buf[256];

static void print_array(const uint8_t *array, size_t len) {
    for (size_t i = 0; i < len; i++) {
        printf(" %02x", array[i]);
    }
    printf("\n");
}

static _Bool arrays_match(const uint8_t *array1, size_t len1,
                          const uint8_t *array2, size_t len2) {
    if (len1 != len2) {
        return false;
    }
    for (size_t i = 0; i < len1; i++) {
        if (array1[i] != array2[i]) {
            return false;
        }
    }
    return true;
}

/// After an instruction is encoded into \c buf, this function receives a
/// pointer \c ptr to the last byte beyond the end of the encoded instruction,
/// and ensures that the encoded instruction consists of exactly
/// \c num_bytes bytes matching the bytes in \c expected.
static void expect(size_t num_bytes,
                   const uint8_t *expected,
                   const uint8_t *ptr,
                   const char *description) {
    size_t buflen = ptr - buf;    // Number of bytes encoded
    if (!arrays_match(expected, num_bytes, buf, buflen)) {
        printf("***** ENCODINGS DO NOT MATCH *****\n");
        printf("Instruction: %s\n", description);
        printf("Expected:    "); print_array(expected, num_bytes);
        printf("Actual:      "); print_array(buf, buflen);
        exit(EXIT_FAILURE);
    }
}

#define EXPECT(expected_num_bytes, expected, call) {   \
    expect(expected_num_bytes, expected, call, #call); \
}

int main() {
    EXPECT(1, ((uint8_t []) { 0x90 }), nop(buf));
    EXPECT(5, ((uint8_t []) { 0xB8, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(EAX, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xB8, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(EAX, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xB8, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(EAX, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xB8, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(EAX, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xB8, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(EAX, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xB8, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(EAX, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xB8, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(EAX, 0x0FFFFFFFF, buf));
    EXPECT(5, ((uint8_t []) { 0xB9, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(ECX, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xB9, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(ECX, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xB9, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(ECX, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xB9, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(ECX, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xB9, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(ECX, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xB9, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(ECX, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xB9, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(ECX, 0x0FFFFFFFF, buf));
    EXPECT(5, ((uint8_t []) { 0xBA, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(EDX, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xBA, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(EDX, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xBA, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(EDX, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xBA, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(EDX, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xBA, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(EDX, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xBA, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(EDX, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xBA, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(EDX, 0x0FFFFFFFF, buf));
    EXPECT(5, ((uint8_t []) { 0xBB, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(EBX, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xBB, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(EBX, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xBB, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(EBX, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xBB, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(EBX, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xBB, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(EBX, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xBB, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(EBX, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xBB, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(EBX, 0x0FFFFFFFF, buf));
    EXPECT(5, ((uint8_t []) { 0xBC, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(ESP, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xBC, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(ESP, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xBC, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(ESP, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xBC, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(ESP, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xBC, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(ESP, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xBC, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(ESP, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xBC, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(ESP, 0x0FFFFFFFF, buf));
    EXPECT(5, ((uint8_t []) { 0xBD, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(EBP, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xBD, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(EBP, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xBD, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(EBP, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xBD, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(EBP, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xBD, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(EBP, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xBD, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(EBP, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xBD, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(EBP, 0x0FFFFFFFF, buf));
    EXPECT(5, ((uint8_t []) { 0xBE, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(ESI, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xBE, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(ESI, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xBE, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(ESI, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xBE, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(ESI, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xBE, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(ESI, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xBE, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(ESI, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xBE, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(ESI, 0x0FFFFFFFF, buf));
    EXPECT(5, ((uint8_t []) { 0xBF, 0x00, 0x00, 0x00, 0x00 }), mov_immediate(EDI, 0, buf));
    EXPECT(5, ((uint8_t []) { 0xBF, 0x01, 0x00, 0x00, 0x00 }), mov_immediate(EDI, 1, buf));
    EXPECT(5, ((uint8_t []) { 0xBF, 0x0F, 0x00, 0x00, 0x00 }), mov_immediate(EDI, 0x0F, buf));
    EXPECT(5, ((uint8_t []) { 0xBF, 0xF0, 0x00, 0x00, 0x00 }), mov_immediate(EDI, 0x0F0, buf));
    EXPECT(5, ((uint8_t []) { 0xBF, 0x78, 0x56, 0x34, 0x12 }), mov_immediate(EDI, 0x12345678, buf));
    EXPECT(5, ((uint8_t []) { 0xBF, 0xFE, 0xFF, 0xFF, 0xFF }), mov_immediate(EDI, 0x0FFFFFFFE, buf));
    EXPECT(5, ((uint8_t []) { 0xBF, 0xFF, 0xFF, 0xFF, 0xFF }), mov_immediate(EDI, 0x0FFFFFFFF, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x00 }), mov_from_ptr(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x01 }), mov_from_ptr(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x02 }), mov_from_ptr(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x03 }), mov_from_ptr(EAX, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x04, 0x24 }), mov_from_ptr(EAX, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x45, 0x00 }), mov_from_ptr(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x06 }), mov_from_ptr(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x07 }), mov_from_ptr(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x08 }), mov_from_ptr(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x09 }), mov_from_ptr(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x0A }), mov_from_ptr(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x0B }), mov_from_ptr(ECX, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x0C, 0x24 }), mov_from_ptr(ECX, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x4D, 0x00 }), mov_from_ptr(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x0E }), mov_from_ptr(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x0F }), mov_from_ptr(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x10 }), mov_from_ptr(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x11 }), mov_from_ptr(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x12 }), mov_from_ptr(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x13 }), mov_from_ptr(EDX, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x14, 0x24 }), mov_from_ptr(EDX, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x55, 0x00 }), mov_from_ptr(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x16 }), mov_from_ptr(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x17 }), mov_from_ptr(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x18 }), mov_from_ptr(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x19 }), mov_from_ptr(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x1A }), mov_from_ptr(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x1B }), mov_from_ptr(EBX, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x1C, 0x24 }), mov_from_ptr(EBX, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x5D, 0x00 }), mov_from_ptr(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x1E }), mov_from_ptr(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x1F }), mov_from_ptr(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x20 }), mov_from_ptr(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x21 }), mov_from_ptr(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x22 }), mov_from_ptr(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x23 }), mov_from_ptr(ESP, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x24, 0x24 }), mov_from_ptr(ESP, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x65, 0x00 }), mov_from_ptr(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x26 }), mov_from_ptr(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x27 }), mov_from_ptr(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x28 }), mov_from_ptr(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x29 }), mov_from_ptr(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x2A }), mov_from_ptr(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x2B }), mov_from_ptr(EBP, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x2C, 0x24 }), mov_from_ptr(EBP, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x6D, 0x00 }), mov_from_ptr(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x2E }), mov_from_ptr(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x2F }), mov_from_ptr(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x30 }), mov_from_ptr(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x31 }), mov_from_ptr(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x32 }), mov_from_ptr(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x33 }), mov_from_ptr(ESI, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x34, 0x24 }), mov_from_ptr(ESI, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x75, 0x00 }), mov_from_ptr(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x36 }), mov_from_ptr(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x37 }), mov_from_ptr(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x38 }), mov_from_ptr(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x39 }), mov_from_ptr(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x3A }), mov_from_ptr(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x3B }), mov_from_ptr(EDI, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x3C, 0x24 }), mov_from_ptr(EDI, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x8B, 0x7D, 0x00 }), mov_from_ptr(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x3E }), mov_from_ptr(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0x3F }), mov_from_ptr(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x00 }), mov_to_ptr(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x01 }), mov_to_ptr(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x02 }), mov_to_ptr(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x03 }), mov_to_ptr(EBX, EAX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x04, 0x24 }), mov_to_ptr(ESP, EAX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x45, 0x00 }), mov_to_ptr(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x06 }), mov_to_ptr(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x07 }), mov_to_ptr(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x08 }), mov_to_ptr(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x09 }), mov_to_ptr(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x0A }), mov_to_ptr(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x0B }), mov_to_ptr(EBX, ECX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x0C, 0x24 }), mov_to_ptr(ESP, ECX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x4D, 0x00 }), mov_to_ptr(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x0E }), mov_to_ptr(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x0F }), mov_to_ptr(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x10 }), mov_to_ptr(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x11 }), mov_to_ptr(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x12 }), mov_to_ptr(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x13 }), mov_to_ptr(EBX, EDX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x14, 0x24 }), mov_to_ptr(ESP, EDX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x55, 0x00 }), mov_to_ptr(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x16 }), mov_to_ptr(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x17 }), mov_to_ptr(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x18 }), mov_to_ptr(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x19 }), mov_to_ptr(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x1A }), mov_to_ptr(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x1B }), mov_to_ptr(EBX, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x1C, 0x24 }), mov_to_ptr(ESP, EBX, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x5D, 0x00 }), mov_to_ptr(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x1E }), mov_to_ptr(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x1F }), mov_to_ptr(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x20 }), mov_to_ptr(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x21 }), mov_to_ptr(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x22 }), mov_to_ptr(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x23 }), mov_to_ptr(EBX, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x24, 0x24 }), mov_to_ptr(ESP, ESP, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x65, 0x00 }), mov_to_ptr(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x26 }), mov_to_ptr(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x27 }), mov_to_ptr(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x28 }), mov_to_ptr(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x29 }), mov_to_ptr(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x2A }), mov_to_ptr(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x2B }), mov_to_ptr(EBX, EBP, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x2C, 0x24 }), mov_to_ptr(ESP, EBP, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x6D, 0x00 }), mov_to_ptr(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x2E }), mov_to_ptr(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x2F }), mov_to_ptr(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x30 }), mov_to_ptr(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x31 }), mov_to_ptr(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x32 }), mov_to_ptr(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x33 }), mov_to_ptr(EBX, ESI, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x34, 0x24 }), mov_to_ptr(ESP, ESI, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x75, 0x00 }), mov_to_ptr(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x36 }), mov_to_ptr(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x37 }), mov_to_ptr(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x38 }), mov_to_ptr(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x39 }), mov_to_ptr(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x3A }), mov_to_ptr(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x3B }), mov_to_ptr(EBX, EDI, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x3C, 0x24 }), mov_to_ptr(ESP, EDI, buf));
    EXPECT(3, ((uint8_t []) { 0x89, 0x7D, 0x00 }), mov_to_ptr(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x3E }), mov_to_ptr(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x89, 0x3F }), mov_to_ptr(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC0 }), mov(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC1 }), mov(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC2 }), mov(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC3 }), mov(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC4 }), mov(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC5 }), mov(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC6 }), mov(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC7 }), mov(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC8 }), mov(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xC9 }), mov(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xCA }), mov(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xCB }), mov(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xCC }), mov(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xCD }), mov(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xCE }), mov(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xCF }), mov(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD0 }), mov(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD1 }), mov(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD2 }), mov(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD3 }), mov(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD4 }), mov(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD5 }), mov(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD6 }), mov(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD7 }), mov(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD8 }), mov(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xD9 }), mov(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xDA }), mov(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xDB }), mov(EBX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xDC }), mov(EBX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xDD }), mov(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xDE }), mov(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xDF }), mov(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE0 }), mov(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE1 }), mov(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE2 }), mov(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE3 }), mov(ESP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE4 }), mov(ESP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE5 }), mov(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE6 }), mov(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE7 }), mov(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE8 }), mov(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xE9 }), mov(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xEA }), mov(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xEB }), mov(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xEC }), mov(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xED }), mov(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xEE }), mov(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xEF }), mov(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF0 }), mov(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF1 }), mov(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF2 }), mov(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF3 }), mov(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF4 }), mov(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF5 }), mov(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF6 }), mov(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF7 }), mov(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF8 }), mov(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xF9 }), mov(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xFA }), mov(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xFB }), mov(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xFC }), mov(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xFD }), mov(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xFE }), mov(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x8B, 0xFF }), mov(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC0 }), add(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC1 }), add(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC2 }), add(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC3 }), add(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC4 }), add(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC5 }), add(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC6 }), add(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC7 }), add(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC8 }), add(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xC9 }), add(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xCA }), add(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xCB }), add(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xCC }), add(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xCD }), add(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xCE }), add(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xCF }), add(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD0 }), add(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD1 }), add(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD2 }), add(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD3 }), add(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD4 }), add(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD5 }), add(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD6 }), add(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD7 }), add(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD8 }), add(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xD9 }), add(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xDA }), add(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xDB }), add(EBX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xDC }), add(EBX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xDD }), add(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xDE }), add(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xDF }), add(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE0 }), add(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE1 }), add(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE2 }), add(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE3 }), add(ESP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE4 }), add(ESP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE5 }), add(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE6 }), add(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE7 }), add(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE8 }), add(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xE9 }), add(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xEA }), add(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xEB }), add(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xEC }), add(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xED }), add(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xEE }), add(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xEF }), add(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF0 }), add(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF1 }), add(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF2 }), add(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF3 }), add(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF4 }), add(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF5 }), add(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF6 }), add(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF7 }), add(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF8 }), add(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xF9 }), add(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xFA }), add(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xFB }), add(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xFC }), add(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xFD }), add(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xFE }), add(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x03, 0xFF }), add(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC0 }), sub(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC1 }), sub(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC2 }), sub(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC3 }), sub(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC4 }), sub(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC5 }), sub(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC6 }), sub(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC7 }), sub(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC8 }), sub(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xC9 }), sub(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xCA }), sub(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xCB }), sub(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xCC }), sub(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xCD }), sub(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xCE }), sub(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xCF }), sub(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD0 }), sub(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD1 }), sub(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD2 }), sub(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD3 }), sub(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD4 }), sub(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD5 }), sub(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD6 }), sub(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD7 }), sub(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD8 }), sub(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xD9 }), sub(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xDA }), sub(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xDB }), sub(EBX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xDC }), sub(EBX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xDD }), sub(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xDE }), sub(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xDF }), sub(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE0 }), sub(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE1 }), sub(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE2 }), sub(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE3 }), sub(ESP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE4 }), sub(ESP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE5 }), sub(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE6 }), sub(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE7 }), sub(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE8 }), sub(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xE9 }), sub(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xEA }), sub(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xEB }), sub(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xEC }), sub(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xED }), sub(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xEE }), sub(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xEF }), sub(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF0 }), sub(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF1 }), sub(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF2 }), sub(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF3 }), sub(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF4 }), sub(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF5 }), sub(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF6 }), sub(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF7 }), sub(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF8 }), sub(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xF9 }), sub(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xFA }), sub(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xFB }), sub(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xFC }), sub(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xFD }), sub(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xFE }), sub(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x2B, 0xFF }), sub(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC0 }), and(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC1 }), and(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC2 }), and(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC3 }), and(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC4 }), and(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC5 }), and(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC6 }), and(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC7 }), and(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC8 }), and(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xC9 }), and(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xCA }), and(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xCB }), and(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xCC }), and(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xCD }), and(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xCE }), and(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xCF }), and(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD0 }), and(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD1 }), and(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD2 }), and(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD3 }), and(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD4 }), and(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD5 }), and(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD6 }), and(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD7 }), and(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD8 }), and(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xD9 }), and(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xDA }), and(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xDB }), and(EBX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xDC }), and(EBX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xDD }), and(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xDE }), and(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xDF }), and(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE0 }), and(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE1 }), and(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE2 }), and(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE3 }), and(ESP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE4 }), and(ESP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE5 }), and(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE6 }), and(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE7 }), and(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE8 }), and(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xE9 }), and(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xEA }), and(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xEB }), and(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xEC }), and(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xED }), and(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xEE }), and(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xEF }), and(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF0 }), and(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF1 }), and(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF2 }), and(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF3 }), and(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF4 }), and(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF5 }), and(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF6 }), and(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF7 }), and(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF8 }), and(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xF9 }), and(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xFA }), and(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xFB }), and(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xFC }), and(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xFD }), and(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xFE }), and(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x23, 0xFF }), and(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC0 }), or(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC1 }), or(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC2 }), or(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC3 }), or(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC4 }), or(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC5 }), or(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC6 }), or(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC7 }), or(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC8 }), or(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xC9 }), or(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xCA }), or(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xCB }), or(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xCC }), or(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xCD }), or(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xCE }), or(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xCF }), or(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD0 }), or(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD1 }), or(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD2 }), or(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD3 }), or(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD4 }), or(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD5 }), or(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD6 }), or(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD7 }), or(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD8 }), or(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xD9 }), or(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xDA }), or(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xDB }), or(EBX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xDC }), or(EBX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xDD }), or(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xDE }), or(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xDF }), or(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE0 }), or(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE1 }), or(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE2 }), or(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE3 }), or(ESP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE4 }), or(ESP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE5 }), or(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE6 }), or(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE7 }), or(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE8 }), or(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xE9 }), or(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xEA }), or(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xEB }), or(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xEC }), or(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xED }), or(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xEE }), or(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xEF }), or(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF0 }), or(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF1 }), or(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF2 }), or(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF3 }), or(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF4 }), or(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF5 }), or(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF6 }), or(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF7 }), or(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF8 }), or(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xF9 }), or(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xFA }), or(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xFB }), or(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xFC }), or(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xFD }), or(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xFE }), or(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x0B, 0xFF }), or(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC0 }), xor(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC1 }), xor(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC2 }), xor(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC3 }), xor(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC4 }), xor(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC5 }), xor(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC6 }), xor(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC7 }), xor(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC8 }), xor(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xC9 }), xor(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xCA }), xor(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xCB }), xor(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xCC }), xor(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xCD }), xor(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xCE }), xor(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xCF }), xor(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD0 }), xor(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD1 }), xor(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD2 }), xor(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD3 }), xor(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD4 }), xor(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD5 }), xor(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD6 }), xor(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD7 }), xor(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD8 }), xor(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xD9 }), xor(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xDA }), xor(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xDB }), xor(EBX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xDC }), xor(EBX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xDD }), xor(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xDE }), xor(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xDF }), xor(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE0 }), xor(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE1 }), xor(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE2 }), xor(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE3 }), xor(ESP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE4 }), xor(ESP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE5 }), xor(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE6 }), xor(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE7 }), xor(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE8 }), xor(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xE9 }), xor(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xEA }), xor(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xEB }), xor(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xEC }), xor(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xED }), xor(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xEE }), xor(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xEF }), xor(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF0 }), xor(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF1 }), xor(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF2 }), xor(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF3 }), xor(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF4 }), xor(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF5 }), xor(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF6 }), xor(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF7 }), xor(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF8 }), xor(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xF9 }), xor(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xFA }), xor(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xFB }), xor(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xFC }), xor(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xFD }), xor(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xFE }), xor(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x33, 0xFF }), xor(EDI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC0 }), cmp(EAX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC1 }), cmp(EAX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC2 }), cmp(EAX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC3 }), cmp(EAX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC4 }), cmp(EAX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC5 }), cmp(EAX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC6 }), cmp(EAX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC7 }), cmp(EAX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC8 }), cmp(ECX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xC9 }), cmp(ECX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xCA }), cmp(ECX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xCB }), cmp(ECX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xCC }), cmp(ECX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xCD }), cmp(ECX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xCE }), cmp(ECX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xCF }), cmp(ECX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD0 }), cmp(EDX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD1 }), cmp(EDX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD2 }), cmp(EDX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD3 }), cmp(EDX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD4 }), cmp(EDX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD5 }), cmp(EDX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD6 }), cmp(EDX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD7 }), cmp(EDX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD8 }), cmp(EBX, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xD9 }), cmp(EBX, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xDA }), cmp(EBX, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xDB }), cmp(EBX, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xDC }), cmp(EBX, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xDD }), cmp(EBX, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xDE }), cmp(EBX, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xDF }), cmp(EBX, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE0 }), cmp(ESP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE1 }), cmp(ESP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE2 }), cmp(ESP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE3 }), cmp(ESP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE4 }), cmp(ESP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE5 }), cmp(ESP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE6 }), cmp(ESP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE7 }), cmp(ESP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE8 }), cmp(EBP, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xE9 }), cmp(EBP, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xEA }), cmp(EBP, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xEB }), cmp(EBP, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xEC }), cmp(EBP, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xED }), cmp(EBP, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xEE }), cmp(EBP, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xEF }), cmp(EBP, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF0 }), cmp(ESI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF1 }), cmp(ESI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF2 }), cmp(ESI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF3 }), cmp(ESI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF4 }), cmp(ESI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF5 }), cmp(ESI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF6 }), cmp(ESI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF7 }), cmp(ESI, EDI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF8 }), cmp(EDI, EAX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xF9 }), cmp(EDI, ECX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xFA }), cmp(EDI, EDX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xFB }), cmp(EDI, EBX, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xFC }), cmp(EDI, ESP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xFD }), cmp(EDI, EBP, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xFE }), cmp(EDI, ESI, buf));
    EXPECT(2, ((uint8_t []) { 0x3B, 0xFF }), cmp(EDI, EDI, buf));
    EXPECT(1, ((uint8_t []) { 0x40 }), inc(EAX, buf));
    EXPECT(1, ((uint8_t []) { 0x41 }), inc(ECX, buf));
    EXPECT(1, ((uint8_t []) { 0x42 }), inc(EDX, buf));
    EXPECT(1, ((uint8_t []) { 0x43 }), inc(EBX, buf));
    EXPECT(1, ((uint8_t []) { 0x44 }), inc(ESP, buf));
    EXPECT(1, ((uint8_t []) { 0x45 }), inc(EBP, buf));
    EXPECT(1, ((uint8_t []) { 0x46 }), inc(ESI, buf));
    EXPECT(1, ((uint8_t []) { 0x47 }), inc(EDI, buf));
    EXPECT(1, ((uint8_t []) { 0x48 }), dec(EAX, buf));
    EXPECT(1, ((uint8_t []) { 0x49 }), dec(ECX, buf));
    EXPECT(1, ((uint8_t []) { 0x4A }), dec(EDX, buf));
    EXPECT(1, ((uint8_t []) { 0x4B }), dec(EBX, buf));
    EXPECT(1, ((uint8_t []) { 0x4C }), dec(ESP, buf));
    EXPECT(1, ((uint8_t []) { 0x4D }), dec(EBP, buf));
    EXPECT(1, ((uint8_t []) { 0x4E }), dec(ESI, buf));
    EXPECT(1, ((uint8_t []) { 0x4F }), dec(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD0 }), not(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD1 }), not(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD2 }), not(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD3 }), not(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD4 }), not(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD5 }), not(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD6 }), not(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD7 }), not(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD8 }), neg(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xD9 }), neg(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xDA }), neg(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xDB }), neg(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xDC }), neg(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xDD }), neg(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xDE }), neg(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xDF }), neg(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE0 }), mul(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE1 }), mul(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE2 }), mul(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE3 }), mul(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE4 }), mul(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE5 }), mul(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE6 }), mul(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE7 }), mul(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE8 }), imul(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xE9 }), imul(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xEA }), imul(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xEB }), imul(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xEC }), imul(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xED }), imul(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xEE }), imul(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xEF }), imul(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF0 }), div_(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF1 }), div_(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF2 }), div_(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF3 }), div_(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF4 }), div_(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF5 }), div_(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF6 }), div_(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF7 }), div_(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF8 }), idiv(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xF9 }), idiv(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xFA }), idiv(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xFB }), idiv(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xFC }), idiv(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xFD }), idiv(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xFE }), idiv(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xF7, 0xFF }), idiv(EDI, buf));
    EXPECT(1, ((uint8_t []) { 0x99 }), cdq(buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE0 }), shl_cl(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE1 }), shl_cl(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE2 }), shl_cl(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE3 }), shl_cl(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE4 }), shl_cl(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE5 }), shl_cl(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE6 }), shl_cl(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE7 }), shl_cl(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE8 }), shr_cl(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xE9 }), shr_cl(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xEA }), shr_cl(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xEB }), shr_cl(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xEC }), shr_cl(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xED }), shr_cl(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xEE }), shr_cl(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xEF }), shr_cl(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xF8 }), sar_cl(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xF9 }), sar_cl(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xFA }), sar_cl(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xFB }), sar_cl(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xFC }), sar_cl(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xFD }), sar_cl(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xFE }), sar_cl(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xD3, 0xFF }), sar_cl(EDI, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE0, 0x00 }), shl(EAX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE0 }), shl(EAX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE0, 0x02 }), shl(EAX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE0, 0x03 }), shl(EAX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE0, 0x20 }), shl(EAX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE0, 0x40 }), shl(EAX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE0, 0x41 }), shl(EAX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE0, 0xFF }), shl(EAX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE1, 0x00 }), shl(ECX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE1 }), shl(ECX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE1, 0x02 }), shl(ECX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE1, 0x03 }), shl(ECX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE1, 0x20 }), shl(ECX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE1, 0x40 }), shl(ECX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE1, 0x41 }), shl(ECX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE1, 0xFF }), shl(ECX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE2, 0x00 }), shl(EDX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE2 }), shl(EDX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE2, 0x02 }), shl(EDX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE2, 0x03 }), shl(EDX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE2, 0x20 }), shl(EDX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE2, 0x40 }), shl(EDX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE2, 0x41 }), shl(EDX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE2, 0xFF }), shl(EDX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE3, 0x00 }), shl(EBX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE3 }), shl(EBX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE3, 0x02 }), shl(EBX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE3, 0x03 }), shl(EBX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE3, 0x20 }), shl(EBX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE3, 0x40 }), shl(EBX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE3, 0x41 }), shl(EBX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE3, 0xFF }), shl(EBX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE4, 0x00 }), shl(ESP, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE4 }), shl(ESP, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE4, 0x02 }), shl(ESP, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE4, 0x03 }), shl(ESP, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE4, 0x20 }), shl(ESP, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE4, 0x40 }), shl(ESP, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE4, 0x41 }), shl(ESP, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE4, 0xFF }), shl(ESP, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE5, 0x00 }), shl(EBP, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE5 }), shl(EBP, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE5, 0x02 }), shl(EBP, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE5, 0x03 }), shl(EBP, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE5, 0x20 }), shl(EBP, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE5, 0x40 }), shl(EBP, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE5, 0x41 }), shl(EBP, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE5, 0xFF }), shl(EBP, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE6, 0x00 }), shl(ESI, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE6 }), shl(ESI, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE6, 0x02 }), shl(ESI, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE6, 0x03 }), shl(ESI, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE6, 0x20 }), shl(ESI, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE6, 0x40 }), shl(ESI, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE6, 0x41 }), shl(ESI, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE6, 0xFF }), shl(ESI, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE7, 0x00 }), shl(EDI, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE7 }), shl(EDI, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE7, 0x02 }), shl(EDI, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE7, 0x03 }), shl(EDI, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE7, 0x20 }), shl(EDI, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE7, 0x40 }), shl(EDI, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE7, 0x41 }), shl(EDI, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE7, 0xFF }), shl(EDI, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE8, 0x00 }), shr(EAX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE8 }), shr(EAX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE8, 0x02 }), shr(EAX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE8, 0x03 }), shr(EAX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE8, 0x20 }), shr(EAX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE8, 0x40 }), shr(EAX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE8, 0x41 }), shr(EAX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE8, 0xFF }), shr(EAX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE9, 0x00 }), shr(ECX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xE9 }), shr(ECX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE9, 0x02 }), shr(ECX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE9, 0x03 }), shr(ECX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE9, 0x20 }), shr(ECX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE9, 0x40 }), shr(ECX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE9, 0x41 }), shr(ECX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xE9, 0xFF }), shr(ECX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEA, 0x00 }), shr(EDX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xEA }), shr(EDX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEA, 0x02 }), shr(EDX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEA, 0x03 }), shr(EDX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEA, 0x20 }), shr(EDX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEA, 0x40 }), shr(EDX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEA, 0x41 }), shr(EDX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEA, 0xFF }), shr(EDX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEB, 0x00 }), shr(EBX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xEB }), shr(EBX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEB, 0x02 }), shr(EBX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEB, 0x03 }), shr(EBX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEB, 0x20 }), shr(EBX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEB, 0x40 }), shr(EBX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEB, 0x41 }), shr(EBX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEB, 0xFF }), shr(EBX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEC, 0x00 }), shr(ESP, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xEC }), shr(ESP, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEC, 0x02 }), shr(ESP, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEC, 0x03 }), shr(ESP, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEC, 0x20 }), shr(ESP, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEC, 0x40 }), shr(ESP, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEC, 0x41 }), shr(ESP, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEC, 0xFF }), shr(ESP, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xED, 0x00 }), shr(EBP, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xED }), shr(EBP, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xED, 0x02 }), shr(EBP, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xED, 0x03 }), shr(EBP, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xED, 0x20 }), shr(EBP, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xED, 0x40 }), shr(EBP, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xED, 0x41 }), shr(EBP, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xED, 0xFF }), shr(EBP, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEE, 0x00 }), shr(ESI, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xEE }), shr(ESI, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEE, 0x02 }), shr(ESI, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEE, 0x03 }), shr(ESI, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEE, 0x20 }), shr(ESI, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEE, 0x40 }), shr(ESI, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEE, 0x41 }), shr(ESI, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEE, 0xFF }), shr(ESI, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEF, 0x00 }), shr(EDI, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xEF }), shr(EDI, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEF, 0x02 }), shr(EDI, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEF, 0x03 }), shr(EDI, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEF, 0x20 }), shr(EDI, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEF, 0x40 }), shr(EDI, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEF, 0x41 }), shr(EDI, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xEF, 0xFF }), shr(EDI, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF8, 0x00 }), sar(EAX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xF8 }), sar(EAX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF8, 0x02 }), sar(EAX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF8, 0x03 }), sar(EAX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF8, 0x20 }), sar(EAX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF8, 0x40 }), sar(EAX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF8, 0x41 }), sar(EAX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF8, 0xFF }), sar(EAX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF9, 0x00 }), sar(ECX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xF9 }), sar(ECX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF9, 0x02 }), sar(ECX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF9, 0x03 }), sar(ECX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF9, 0x20 }), sar(ECX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF9, 0x40 }), sar(ECX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF9, 0x41 }), sar(ECX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xF9, 0xFF }), sar(ECX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFA, 0x00 }), sar(EDX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xFA }), sar(EDX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFA, 0x02 }), sar(EDX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFA, 0x03 }), sar(EDX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFA, 0x20 }), sar(EDX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFA, 0x40 }), sar(EDX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFA, 0x41 }), sar(EDX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFA, 0xFF }), sar(EDX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFB, 0x00 }), sar(EBX, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xFB }), sar(EBX, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFB, 0x02 }), sar(EBX, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFB, 0x03 }), sar(EBX, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFB, 0x20 }), sar(EBX, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFB, 0x40 }), sar(EBX, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFB, 0x41 }), sar(EBX, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFB, 0xFF }), sar(EBX, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFC, 0x00 }), sar(ESP, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xFC }), sar(ESP, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFC, 0x02 }), sar(ESP, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFC, 0x03 }), sar(ESP, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFC, 0x20 }), sar(ESP, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFC, 0x40 }), sar(ESP, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFC, 0x41 }), sar(ESP, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFC, 0xFF }), sar(ESP, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFD, 0x00 }), sar(EBP, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xFD }), sar(EBP, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFD, 0x02 }), sar(EBP, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFD, 0x03 }), sar(EBP, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFD, 0x20 }), sar(EBP, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFD, 0x40 }), sar(EBP, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFD, 0x41 }), sar(EBP, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFD, 0xFF }), sar(EBP, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFE, 0x00 }), sar(ESI, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xFE }), sar(ESI, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFE, 0x02 }), sar(ESI, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFE, 0x03 }), sar(ESI, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFE, 0x20 }), sar(ESI, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFE, 0x40 }), sar(ESI, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFE, 0x41 }), sar(ESI, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFE, 0xFF }), sar(ESI, 0x0FF, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFF, 0x00 }), sar(EDI, 0, buf));
    EXPECT(2, ((uint8_t []) { 0xD1, 0xFF }), sar(EDI, 1, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFF, 0x02 }), sar(EDI, 2, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFF, 0x03 }), sar(EDI, 3, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFF, 0x20 }), sar(EDI, 0x20, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFF, 0x40 }), sar(EDI, 0x40, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFF, 0x41 }), sar(EDI, 0x41, buf));
    EXPECT(3, ((uint8_t []) { 0xC1, 0xFF, 0xFF }), sar(EDI, 0x0FF, buf));
    EXPECT(1, ((uint8_t []) { 0x50 }), push(EAX, buf));
    EXPECT(1, ((uint8_t []) { 0x51 }), push(ECX, buf));
    EXPECT(1, ((uint8_t []) { 0x52 }), push(EDX, buf));
    EXPECT(1, ((uint8_t []) { 0x53 }), push(EBX, buf));
    EXPECT(1, ((uint8_t []) { 0x54 }), push(ESP, buf));
    EXPECT(1, ((uint8_t []) { 0x55 }), push(EBP, buf));
    EXPECT(1, ((uint8_t []) { 0x56 }), push(ESI, buf));
    EXPECT(1, ((uint8_t []) { 0x57 }), push(EDI, buf));
    EXPECT(1, ((uint8_t []) { 0x58 }), pop(EAX, buf));
    EXPECT(1, ((uint8_t []) { 0x59 }), pop(ECX, buf));
    EXPECT(1, ((uint8_t []) { 0x5A }), pop(EDX, buf));
    EXPECT(1, ((uint8_t []) { 0x5B }), pop(EBX, buf));
    EXPECT(1, ((uint8_t []) { 0x5C }), pop(ESP, buf));
    EXPECT(1, ((uint8_t []) { 0x5D }), pop(EBP, buf));
    EXPECT(1, ((uint8_t []) { 0x5E }), pop(ESI, buf));
    EXPECT(1, ((uint8_t []) { 0x5F }), pop(EDI, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD0 }), call(EAX, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD1 }), call(ECX, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD2 }), call(EDX, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD3 }), call(EBX, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD4 }), call(ESP, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD5 }), call(EBP, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD6 }), call(ESI, buf));
    EXPECT(2, ((uint8_t []) { 0xFF, 0xD7 }), call(EDI, buf));
    EXPECT(1, ((uint8_t []) { 0xC3 }), ret(0, buf));
    EXPECT(3, ((uint8_t []) { 0xC2, 0x01, 0x00 }), ret(1, buf));
    EXPECT(3, ((uint8_t []) { 0xC2, 0x02, 0x00 }), ret(2, buf));
    EXPECT(3, ((uint8_t []) { 0xC2, 0x04, 0x00 }), ret(4, buf));
    EXPECT(3, ((uint8_t []) { 0xC2, 0x10, 0x00 }), ret(0x10, buf));
    EXPECT(3, ((uint8_t []) { 0xC2, 0x00, 0x01 }), ret(0x100, buf));
    EXPECT(2, ((uint8_t []) { 0xEB, 0xFE }), jmp(-2, buf));
    EXPECT(2, ((uint8_t []) { 0xEB, 0x00 }), jmp(0, buf));
    EXPECT(2, ((uint8_t []) { 0xEB, 0x05 }), jmp(5, buf));
    EXPECT(2, ((uint8_t []) { 0xEB, 0x0A }), jmp(10, buf));
    EXPECT(2, ((uint8_t []) { 0xEB, 0x64 }), jmp(100, buf));
    EXPECT(5, ((uint8_t []) { 0xE9, 0xC8, 0x00, 0x00, 0x00 }), jmp(200, buf));
    EXPECT(5, ((uint8_t []) { 0xE9, 0x2C, 0x01, 0x00, 0x00 }), jmp(300, buf));
    EXPECT(2, ((uint8_t []) { 0x72, 0xFE }), jb(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x72, 0x00 }), jb(0, buf));
    EXPECT(2, ((uint8_t []) { 0x72, 0x05 }), jb(5, buf));
    EXPECT(2, ((uint8_t []) { 0x72, 0x0A }), jb(10, buf));
    EXPECT(2, ((uint8_t []) { 0x72, 0x64 }), jb(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x82, 0xC8, 0x00, 0x00, 0x00 }), jb(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x82, 0x2C, 0x01, 0x00, 0x00 }), jb(300, buf));
    EXPECT(2, ((uint8_t []) { 0x73, 0xFE }), jae(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x73, 0x00 }), jae(0, buf));
    EXPECT(2, ((uint8_t []) { 0x73, 0x05 }), jae(5, buf));
    EXPECT(2, ((uint8_t []) { 0x73, 0x0A }), jae(10, buf));
    EXPECT(2, ((uint8_t []) { 0x73, 0x64 }), jae(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x83, 0xC8, 0x00, 0x00, 0x00 }), jae(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x83, 0x2C, 0x01, 0x00, 0x00 }), jae(300, buf));
    EXPECT(2, ((uint8_t []) { 0x74, 0xFE }), je(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x74, 0x00 }), je(0, buf));
    EXPECT(2, ((uint8_t []) { 0x74, 0x05 }), je(5, buf));
    EXPECT(2, ((uint8_t []) { 0x74, 0x0A }), je(10, buf));
    EXPECT(2, ((uint8_t []) { 0x74, 0x64 }), je(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x84, 0xC8, 0x00, 0x00, 0x00 }), je(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x84, 0x2C, 0x01, 0x00, 0x00 }), je(300, buf));
    EXPECT(2, ((uint8_t []) { 0x75, 0xFE }), jne(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x75, 0x00 }), jne(0, buf));
    EXPECT(2, ((uint8_t []) { 0x75, 0x05 }), jne(5, buf));
    EXPECT(2, ((uint8_t []) { 0x75, 0x0A }), jne(10, buf));
    EXPECT(2, ((uint8_t []) { 0x75, 0x64 }), jne(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x85, 0xC8, 0x00, 0x00, 0x00 }), jne(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x85, 0x2C, 0x01, 0x00, 0x00 }), jne(300, buf));
    EXPECT(2, ((uint8_t []) { 0x76, 0xFE }), jbe(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x76, 0x00 }), jbe(0, buf));
    EXPECT(2, ((uint8_t []) { 0x76, 0x05 }), jbe(5, buf));
    EXPECT(2, ((uint8_t []) { 0x76, 0x0A }), jbe(10, buf));
    EXPECT(2, ((uint8_t []) { 0x76, 0x64 }), jbe(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x86, 0xC8, 0x00, 0x00, 0x00 }), jbe(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x86, 0x2C, 0x01, 0x00, 0x00 }), jbe(300, buf));
    EXPECT(2, ((uint8_t []) { 0x77, 0xFE }), ja(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x77, 0x00 }), ja(0, buf));
    EXPECT(2, ((uint8_t []) { 0x77, 0x05 }), ja(5, buf));
    EXPECT(2, ((uint8_t []) { 0x77, 0x0A }), ja(10, buf));
    EXPECT(2, ((uint8_t []) { 0x77, 0x64 }), ja(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x87, 0xC8, 0x00, 0x00, 0x00 }), ja(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x87, 0x2C, 0x01, 0x00, 0x00 }), ja(300, buf));
    EXPECT(2, ((uint8_t []) { 0x7C, 0xFE }), jl(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x7C, 0x00 }), jl(0, buf));
    EXPECT(2, ((uint8_t []) { 0x7C, 0x05 }), jl(5, buf));
    EXPECT(2, ((uint8_t []) { 0x7C, 0x0A }), jl(10, buf));
    EXPECT(2, ((uint8_t []) { 0x7C, 0x64 }), jl(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8C, 0xC8, 0x00, 0x00, 0x00 }), jl(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8C, 0x2C, 0x01, 0x00, 0x00 }), jl(300, buf));
    EXPECT(2, ((uint8_t []) { 0x7D, 0xFE }), jge(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x7D, 0x00 }), jge(0, buf));
    EXPECT(2, ((uint8_t []) { 0x7D, 0x05 }), jge(5, buf));
    EXPECT(2, ((uint8_t []) { 0x7D, 0x0A }), jge(10, buf));
    EXPECT(2, ((uint8_t []) { 0x7D, 0x64 }), jge(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8D, 0xC8, 0x00, 0x00, 0x00 }), jge(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8D, 0x2C, 0x01, 0x00, 0x00 }), jge(300, buf));
    EXPECT(2, ((uint8_t []) { 0x7E, 0xFE }), jle(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x7E, 0x00 }), jle(0, buf));
    EXPECT(2, ((uint8_t []) { 0x7E, 0x05 }), jle(5, buf));
    EXPECT(2, ((uint8_t []) { 0x7E, 0x0A }), jle(10, buf));
    EXPECT(2, ((uint8_t []) { 0x7E, 0x64 }), jle(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8E, 0xC8, 0x00, 0x00, 0x00 }), jle(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8E, 0x2C, 0x01, 0x00, 0x00 }), jle(300, buf));
    EXPECT(2, ((uint8_t []) { 0x7F, 0xFE }), jg(-2, buf));
    EXPECT(2, ((uint8_t []) { 0x7F, 0x00 }), jg(0, buf));
    EXPECT(2, ((uint8_t []) { 0x7F, 0x05 }), jg(5, buf));
    EXPECT(2, ((uint8_t []) { 0x7F, 0x0A }), jg(10, buf));
    EXPECT(2, ((uint8_t []) { 0x7F, 0x64 }), jg(100, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8F, 0xC8, 0x00, 0x00, 0x00 }), jg(200, buf));
    EXPECT(6, ((uint8_t []) { 0x0F, 0x8F, 0x2C, 0x01, 0x00, 0x00 }), jg(300, buf));
    printf("All tests passed!\n");
    return EXIT_SUCCESS;
}