   flag_set(FLAG_N, false);
 }
 
+// [80] ADD A, B
+def op_80() {
+  *A = om_add8(*A, *B);
+}
+
+// [81] ADD A, C
+def op_81() {
+  *A = om_add8(*A, *C);
+}
+
+// [82] ADD A, D
+def op_82() {
+  *A = om_add8(*A, *C);
+}
+
+// [83] ADD A, E
+def op_83() {
+  *A = om_add8(*A, *E);
+}
+
+// [84] ADD A, H
+def op_84() {
+  *A = om_add8(*A, *H);
+}
+
+// [85] ADD A, L
+def op_85() {
+  *A = om_add8(*A, *L);
+}
+
+// [86] ADD A, (HL)
+def op_86() {
+  *A = om_add8(*A, mmu_read8(HL));
+}
+
+// [87] ADD A, A
+def op_87() {
+  *A = om_add8(*A, *A);
+}
+
+// [88] ADC A, B
+def op_88() {
+  *A = om_adc8(*A, *B);
+}
+
+// [89] ADC A, C
+def op_89() {
+  *A = om_adc8(*A, *C);
+}
+
+// [8A] ADC A, D
+def op_8A() {
+  *A = om_adc8(*A, *C);
+}
+
+// [8B] ADC A, E
+def op_8B() {
+  *A = om_adc8(*A, *E);
+}
+
+// [8C] ADC A, H
+def op_8C() {
+  *A = om_adc8(*A, *H);
+}
+
+// [8D] ADC A, L
+def op_8D() {
+  *A = om_adc8(*A, *L);
+}
+
+// [8E] ADC A, (HL)
+def op_8E() {
+  *A = om_adc8(*A, mmu_read8(HL));
+}
+
+// [8F] ADC A, A
+def op_8F() {
+  *A = om_adc8(*A, *A);
+}
+
+// [90] SUB A, B
+def op_90() {
+  *A = om_sub8(*A, *B);
+}
+
+// [91] SUB A, C
+def op_91() {
+  *A = om_sub8(*A, *C);
+}
+
+// [92] SUB A, D
+def op_92() {
+  *A = om_sub8(*A, *C);
+}
+
+// [93] SUB A, E
+def op_93() {
+  *A = om_sub8(*A, *E);
+}
+
+// [94] SUB A, H
+def op_94() {
+  *A = om_sub8(*A, *H);
+}
+
+// [95] SUB A, L
+def op_95() {
+  *A = om_sub8(*A, *L);
+}
+
+// [96] SUB A, (HL)
+def op_96() {
+  *A = om_sub8(*A, mmu_read8(HL));
+}
+
+// [97] SUB A, A
+def op_97() {
+  *A = om_sub8(*A, *A);
+}
+
+// [98] SBC A, B
+def op_98() {
+  *A = om_sbc8(*A, *B);
+}
+
+// [99] SBC A, C
+def op_99() {
+  *A = om_sbc8(*A, *C);
+}
+
+// [9A] SBC A, D
+def op_9A() {
+  *A = om_sbc8(*A, *C);
+}
+
+// [9B] SBC A, E
+def op_9B() {
+  *A = om_sbc8(*A, *E);
+}
+
+// [9C] SBC A, H
+def op_9C() {
+  *A = om_sbc8(*A, *H);
+}
+
+// [9D] SBC A, L
+def op_9D() {
+  *A = om_sbc8(*A, *L);
+}
+
+// [9E] SBC A, (HL)
+def op_9E() {
+  *A = om_sbc8(*A, mmu_read8(HL));
+}
+
+// [9F] SBC A, A
+def op_9F() {
+  *A = om_sbc8(*A, *A);
+}
+
+// [A0] AND A, B
+def op_A0() {
+  *A = om_and8(*A, *B);
+}
+
+// [A1] AND A, C
+def op_A1() {
+  *A = om_and8(*A, *C);
+}
+
+// [A2] AND A, D
+def op_A2() {
+  *A = om_and8(*A, *C);
+}
+
+// [A3] AND A, E
+def op_A3() {
+  *A = om_and8(*A, *E);
+}
+
+// [A4] AND A, H
+def op_A4() {
+  *A = om_and8(*A, *H);
+}
+
+// [A5] AND A, L
+def op_A5() {
+  *A = om_and8(*A, *L);
+}
+
+// [A6] AND A, (HL)
+def op_A6() {
+  *A = om_and8(*A, mmu_read8(HL));
+}
+
+// [A7] AND A, A
+def op_A7() {
+  *A = om_and8(*A, *A);
+}
+
+// [A8] XOR A, B
+def op_A8() {
+  *A = om_xor8(*A, *B);
+}
+
+// [A9] XOR A, C
+def op_A9() {
+  *A = om_xor8(*A, *C);
+}
+
+// [AA] XOR A, D
+def op_AA() {
+  *A = om_xor8(*A, *C);
+}
+
+// [AB] XOR A, E
+def op_AB() {
+  *A = om_xor8(*A, *E);
+}
+
+// [AC] XOR A, H
+def op_AC() {
+  *A = om_xor8(*A, *H);
+}
+
+// [AD] XOR A, L
+def op_AD() {
+  *A = om_xor8(*A, *L);
+}
+
+// [AE] XOR A, (HL)
+def op_AE() {
+  *A = om_xor8(*A, mmu_read8(HL));
+}
+
+// [AF] XOR A, A
+def op_AF() {
+  *A = om_xor8(*A, *A);
+}
+
+// [B0] OR A, B
+def op_B0() {
+  *A = om_or8(*A, *B);
+}
+
+// [B1] OR A, C
+def op_B1() {
+  *A = om_or8(*A, *C);
+}
+
+// [B2] OR A, D
+def op_B2() {
+  *A = om_or8(*A, *C);
+}
+
+// [B3] OR A, E
+def op_B3() {
+  *A = om_or8(*A, *E);
+}
+
+// [B4] OR A, H
+def op_B4() {
+  *A = om_or8(*A, *H);
+}
+
+// [B5] OR A, L
+def op_B5() {
+  *A = om_or8(*A, *L);
+}
+
+// [B6] OR A, (HL)
+def op_B6() {
+  *A = om_or8(*A, mmu_read8(HL));
+}
+
+// [B7] OR A, A
+def op_B7() {
+  *A = om_or8(*A, *A);
+}
+
+// [B8] CP A, B
+def op_B8() {
+  om_sub8(*A, *B);
+}
+
+// [B9] CP A, C
+def op_B9() {
+  om_sub8(*A, *C);
+}
+
+// [BA] CP A, D
+def op_BA() {
+  om_sub8(*A, *C);
+}
+
+// [BB] CP A, E
+def op_BB() {
+  om_sub8(*A, *E);
+}
+
+// [BC] CP A, H
+def op_BC() {
+  om_sub8(*A, *H);
+}
+
+// [BD] CP A, L
+def op_BD() {
+  om_sub8(*A, *L);
+}
+
+// [BE] CP A, (HL)
+def op_BE() {
+  om_sub8(*A, mmu_read8(HL));
+}
+
+// [BF] CP A, A
+def op_BF() {
+  om_sub8(*A, *A);
+}
+
 // [C0] RET NZ
 def op_C0() {
   if not flag_get(FLAG_Z) {

  *(optable + 0x3E) = op_3E;
  *(optable + 0x3F) = op_3F;

  *(optable + 0xC0) = op_C0;
  *(optable + 0xC1) = op_C1;
  *(optable + 0xC2) = op_C2;


// TODO: Determine if AF is stored as AF or FA in memory
// TODO: Finish opcodes
// TODO: Timing
// TODO: Tileset rendering

// libc
type size_t = int64;
