from cpu6502 import *
import unittest


class TestCPU6502(unittest.TestCase):

   def setUp(self):
       self.cpu = CPU6502()
       self.cpu.pc = 0x7000
       self.cpu.start = self.cpu.pc
       self.debug = False
       print("")
       print("---------------------------")
       print("test method: %s" % self._testMethodName)

   def check_flags(self, neg, zero, carry):
       self.assertEqual(self.cpu.flag_n, neg)
       self.assertEqual(self.cpu.flag_z, zero)
       self.assertEqual(self.cpu.flag_c, carry)

   def check_a(self, val, neg, zero, carry):
       self.assertEqual(self.cpu.reg_a, val)
       self.check_flags(neg, zero, carry)

   def check_x(self, val, neg, zero, carry):
       self.assertEqual(self.cpu.reg_x, val)
       self.check_flags(neg, zero, carry)

   def check_y(self, val, neg, zero, carry):
       self.assertEqual(self.cpu.reg_y, val)
       self.check_flags(neg, zero, carry)

   def check_mem(self, adr, val, neg, zero):
       self.assertEqual(self.cpu.mem[adr], val)
       self.assertEqual(self.cpu.flag_n, neg)
       self.assertEqual(self.cpu.flag_z, zero)

   def listing(self):
       self.cpu.end = self.cpu.pc
       self.cpu.disass()

   def run_test(self, debug=False):
       self.cpu.resetcyc()
       if self.debug:
           self.listing()
       self.cpu.run()
       if self.debug:
           self.cpu.registers()
           print("")
           print("Cycles: %d" % (self.cpu.cycles))
           print("")
       self.assertEqual(0xff, self.cpu.sp)

   def test_adc_imm_1(self):
       # 15 + 21 = 36
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('adc #', 21)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(36, False, False, False)

   def test_adc_imm_2(self):
       # 15 + 21 + Carry = 37
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('adc #', 21)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(37, False, False, False)

   def test_adc_imm_3(self):
       # 100 + 28 = 128 und Neg gesetzt
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('adc #', 28)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_adc_imm_4(self):
       # 100 + 156 = $0100 = 0 (lowbyte) und Carry gesetzt
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('adc #', 156)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_adc_zp_1(self):
       # [aa] = 21; 15 + [aa] = 36
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('adc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(36, False, False, False)

   def test_adc_zp_2(self):
       # [aa] = 21; 15 + [aa] + Carry = 37
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('adc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(37, False, False, False)

   def test_adc_zp_3(self):
       # [aa] = 28; 100 + [aa] = 128 und Neg gesetzt
       self.cpu.addcmd('ldx #', 28)
       self.cpu.addcmd2('stx aa', 0xc6)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd2('adc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_adc_zp_4(self):
       # [aa] = 156; 100 + [aa] = $0100 = 0 (lowbyte) und Carry gesetzt
       self.cpu.addcmd('ldx #', 156)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('adc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_adc_abs_1(self):
       # [aaaa] = 21; 15 + [aaaa] = 36
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd2('adc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(36, False, False, False)

   def test_adc_abs_2(self):
       # [aaaa] = 21; 15 + [aaaa] + Carry = 37
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('sec')
       self.cpu.addcmd2('adc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(37, False, False, False)

   def test_adc_abs_3(self):
       # [aaaa] = 28; 100 + [aaaa] = 128 und Neg gesetzt
       self.cpu.addcmd('ldx #', 28)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd2('adc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_adc_abs_4(self):
       # [aaaa] = 156; 100 + [aaaa] = $0100 = 0 (lowbyte) und Carry gesetzt
       self.cpu.addcmd('ldx #', 156)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd2('adc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_adc_abs_x_1(self):
       # [aaaa,x] = 21; 15 + [aaaa,x] = 36
       self.cpu.addcmd('ldy #', 21)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd2('adc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(36, False, False, False)

   def test_adc_abs_x_2(self):
       # [aaaa,x] = 21; 15 + [aaaa,x] + Carry = 37
       self.cpu.addcmd('ldy #', 21)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('sec')
       self.cpu.addcmd2('adc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(37, False, False, False)

   def test_adc_abs_x_3(self):
       # [aaaa,x] = 28; 100 + [aaaa,x] = 128 und Neg gesetzt
       self.cpu.addcmd('ldy #', 28)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd2('adc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_adc_abs_x_4(self):
       # [aaaa,x] = 156; 100 + [aaaa,x] = $0100 = 0 (lowbyte) und Carry gesetzt
       self.cpu.addcmd('ldy #', 156)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd2('adc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_adc_abs_y_1(self):
       # [aaaa,y] = 21; 15 + [aaaa,y] = 36
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd2('adc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(36, False, False, False)

   def test_adc_abs_y_2(self):
       # [aaaa,y] = 21; 15 + [aaaa,y] + Carry = 37
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('sec')
       self.cpu.addcmd2('adc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(37, False, False, False)

   def test_adc_abs_y_3(self):
       # [aaaa,y] = 28; 100 + [aaaa,y] = 128 und Neg gesetzt
       self.cpu.addcmd('ldx #', 28)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd2('adc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_adc_abs_y_4(self):
       # [aaaa,y] = 156; 100 + [aaaa,y] = $0100 = 0 (lowbyte) und Carry gesetzt
       self.cpu.addcmd('ldx #', 156)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('clc')
       self.cpu.addcmd2('adc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_asl_1(self):
       #    1010 1010  170
       # << 0101 0100   84 und Carry gesetzt
       self.cpu.addcmd('lda #', 170)
       self.cpu.addcmd('asl A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(84, False, False, True)

   def test_asl_2(self):
       #    0101 0100   84
       # << 1010 1000  168
       self.cpu.addcmd('lda #', 84)
       self.cpu.addcmd('asl A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(168, True, False, False)

   def test_asl_zp_1(self):
       #    1010 1010  170
       # << 0101 0100   84 und Carry gesetzt
       self.cpu.addcmd('lda #', 170)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('asl aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 84, False, False)
       self.assertTrue(self.cpu.flag_c)

   def test_asl_zp_2(self):
       #    0101 0100   84
       # << 1010 1000  168
       self.cpu.addcmd('lda #', 84)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('asl aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 168, True, False)
       self.assertFalse(self.cpu.flag_c)

   def test_and_imm_1(self):
       #   1110 0100   228
       # & 0101 0101    85
       # = 0100 0100    68
       self.cpu.addcmd('lda #', 228)
       self.cpu.addcmd('and #', 85)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(68, False, False, False)

   def test_and_imm_2(self):
       #   1111 1111
       # & 0000 0000
       # = 0000 0000
       self.cpu.addcmd('lda #', 255)
       self.cpu.addcmd('and #', 0)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, False)

   def test_and_imm_3(self):
       #   1111 1111
       # & 1000 0000
       # = 1000 0000
       self.cpu.addcmd('lda #', 255)
       self.cpu.addcmd('and #', 128)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_bcc_1(self):
       # kein Sprung: X = 0, C = 1 -> X = 1, C = 1
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('bcc aa', 0x01)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(1, False, False, True)

   def test_bcc_2(self):
       # Vorwaertssprung: X = 0, C = 0 -> X = 0, C = 0
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('bcc aa', 0x01)
       self.cpu.addcmd('dex')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, False)

   def test_bcc_3(self):
       # Schleife mit Rueckwaertssprung (16 Durchlaeufe)
       #    A = $00, $10, $20, ... , $e0
       # -> A = $10, $20, $30, ... , $f0; C = 0, Y = 1..15
       # ->                      A = $00, C = 1, Y = 16
       self.cpu.addcmd('lda #', 0)
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('iny')
       self.cpu.addcmd('clc')
       self.cpu.addcmd('adc #', 0x10)
       self.cpu.addcmd('bcc aa', 0xfa)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)
       # Flags nicht pruefen wg. adc #
       self.assertEqual(self.cpu.reg_y, 16)

   def test_bcs_1(self):
       # kein Sprung: X = 0, C = 0 -> X = 1, C = 0
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('bcs aa', 0x01)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(1, False, False, False)

   def test_bcs_2(self):
       # Vorwaertssprung: X = 0, C = 1 -> X = 0, C = 1
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('bcs aa', 0x01)
       self.cpu.addcmd('dex')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, True)

   def test_bcs_3(self):
       # Schleife mit Rueckwaertssprung (16 Durchlaeufe)
       #    A = $ff, $ef, $df, ... , $1f
       # -> A = $ef, $df, $cf, ... , $0f; C = 1, Y = 1..15
       # ->                      A = $ff, C = 0, Y = 16
       self.cpu.addcmd('lda #', 0xff)
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('iny')
       self.cpu.addcmd('sec')
       self.cpu.addcmd('sbc #', 0x10)
       self.cpu.addcmd('bcs aa', 0xfa)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(255, True, False, False)
       # Flags nicht pruefen wg. sbc #
       self.assertEqual(self.cpu.reg_y, 16)

   def test_beq_1(self):
       # kein Sprung -> X = 2
       self.cpu.addcmd('ldx #', 1)
       self.cpu.addcmd('beq aa', 0x01)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(2, False, False, False)

   def test_beq_2(self):
       # Vorwaertssprung -> X = 0
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('beq aa', 0x01)
       self.cpu.addcmd('dex')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, False)

   def test_beq_3(self):
       # Schleife X=1..0 mit Rueckwaertssprung (2 Durchlaeufe)
       # -> X = 255; Y = 2
       self.cpu.addcmd('ldx #', 1)
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('iny')
       self.cpu.addcmd('dex')
       self.cpu.addcmd('beq aa', 0xfc)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(255, True, False, False)
       # Flags nicht pruefen wg dex
       self.assertEqual(self.cpu.reg_y, 2)

   def test_bne_1(self):
       # kein Sprung -> X = 1
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('bne aa', 0x01)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(1, False, False, False)

   def test_bne_2(self):
       # Vorwaertssprung -> X = 1
       self.cpu.addcmd('ldx #', 1)
       self.cpu.addcmd('bne aa', 0x01)
       self.cpu.addcmd('dex')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(1, False, False, False)

   def test_bne_3(self):
       # Schleife X=10..1 mit Rueckwaertssprung (10 Durchlaeufe)
       # -> X = 0; Y = 10
       self.cpu.addcmd('ldx #', 10)
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('iny')
       self.cpu.addcmd('dex')
       self.cpu.addcmd('bne aa', 0xfc)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, False)
       # Flags nicht pruefen wg. dex
       self.assertEqual(self.cpu.reg_y, 10)

   def test_bpl_1(self):
       # kein Sprung -> X = 0
       self.cpu.addcmd('ldx #', 0xff)
       self.cpu.addcmd('bpl aa', 0x01)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, False)

   def test_bpl_2(self):
       # Vorwaertssprung -> X = 127
       self.cpu.addcmd('ldx #', 0x7f)
       self.cpu.addcmd('bpl aa', 0x01)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(127, False, False, False)

   def test_bpl_3(self):
       # Schleife X=10..0 mit Rueckwaertssprung (11 Durchlaeufe)
       # -> X = 255; Y = 11
       self.cpu.addcmd('ldx #', 10)
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('iny')
       self.cpu.addcmd('dex')
       self.cpu.addcmd('bpl aa', 0xfc)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(255, True, False, False)
       # Flags nicht pruefen wg. dex
       self.assertEqual(self.cpu.reg_y, 11)

   def compare_eql(self):
       """ Testet die Flags fuer A == B """
       self.assertFalse(self.cpu.flag_n)
       self.assertTrue(self.cpu.flag_z)
       self.assertTrue(self.cpu.flag_c)

   def compare_gtr(self):
       """ Testet die Flags fuer A > B """
       self.assertFalse(self.cpu.flag_n)
       self.assertFalse(self.cpu.flag_z)
       self.assertTrue(self.cpu.flag_c)

   def compare_lss(self):
       """ Testet die Flags fuer A < B """
       self.assertTrue(self.cpu.flag_n)
       self.assertFalse(self.cpu.flag_z)
       self.assertFalse(self.cpu.flag_c)

   def test_cmp_imm_1(self):
       # A == val
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('cmp #', 16)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cmp_imm_2(self):
       # A > val
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('cmp #', 15)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cmp_imm_3(self):
       # A < val
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('cmp #', 16)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cmp_zp_1(self):
       # A == [aa]
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('cmp aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cmp_zp_2(self):
       # A > [aa]
       self.cpu.addcmd('ldx #', 15)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('cmp aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cmp_zp_3(self):
       # A < [aa]
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('cmp aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cmp_abs_1(self):
       # A == [aaaa]
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('cmp aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cmp_abs_2(self):
       # A > [aaaa]
       self.cpu.addcmd('ldx #', 15)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('cmp aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cmp_abs_3(self):
       # A < [aaaa]
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd2('cmp aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cmp_abs_x_1(self):
       # X = 4; A == [aaaa,x]
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('cmp aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cmp_abs_x_2(self):
       # X = 4; A > [aaaa,x]
       self.cpu.addcmd('ldy #', 15)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd2('cmp aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cmp_abs_x_3(self):
       # X = 4; A < [aaaa,x]
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd2('cmp aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cmp_abs_y_1(self):
       # Y = 4; A == [aaaa,y]
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('cmp aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cmp_abs_y_2(self):
       # Y = 4; A > [aaaa,y]
       self.cpu.addcmd('ldx #', 15)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd2('cmp aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cmp_abs_y_3(self):
       # Y = 4; A < [aaaa,y]
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd2('cmp aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cpx_imm_1(self):
       # X == val
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd('cpx #', 16)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cpx_imm_2(self):
       # X > val
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd('cpx #', 15)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cpx_imm_3(self):
       # X < val
       self.cpu.addcmd('ldx #', 15)
       self.cpu.addcmd('cpx #', 16)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cpx_zp_1(self):
       # X == [aa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd('cpx aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cpx_zp_2(self):
       # X > [aa]
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd('cpx aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cpx_zp_3(self):
       # X < [aa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ldx #', 15)
       self.cpu.addcmd('cpx aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cpx_abs_1(self):
       # X == [aaaa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('sta aaaa', 0x2000)
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd2('cpx aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cpx_abs_2(self):
       # X > [aaaa]
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd2('sta aaaa', 0x2000)
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd2('cpx aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cpx_abs_3(self):
       # X < [aaaa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('sta aaaa', 0x2000)
       self.cpu.addcmd('ldx #', 15)
       self.cpu.addcmd2('cpx aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cpy_imm_1(self):
       # Y == val
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd('cpy #', 16)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cpy_imm_2(self):
       # Y > val
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd('cpy #', 15)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cpy_imm_3(self):
       # Y < val
       self.cpu.addcmd('ldy #', 15)
       self.cpu.addcmd('cpy #', 16)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cpy_zp_1(self):
       # Y == [aa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd('cpy aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cpy_zp_2(self):
       # Y > [aa]
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd('cpy aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cpy_zp_3(self):
       # Y < [aa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ldy #', 15)
       self.cpu.addcmd('cpy aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_cpy_abs_1(self):
       # Y == [aaaa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('sta aaaa', 0x2000)
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd2('cpy aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_eql()

   def test_cpy_abs_2(self):
       # Y > [aaaa]
       self.cpu.addcmd('lda #', 15)
       self.cpu.addcmd2('sta aaaa', 0x2000)
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd2('cpy aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_gtr()

   def test_cpy_abs_3(self):
       # Y < [aaaa]
       self.cpu.addcmd('lda #', 16)
       self.cpu.addcmd2('sta aaaa', 0x2000)
       self.cpu.addcmd('ldy #', 15)
       self.cpu.addcmd2('cpy aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.compare_lss()

   def test_dec_zp_1(self):
       # 1 -> $c6, DEC -> 0, Zero-Flag
       self.cpu.addcmd('ldx #', 1)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('dec aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 0, False, True)

   def test_dec_zp_2(self):
       # 0 -> $c6, DEC -> 255, N-Flag
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('dec aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 255, True, False)

   def test_dec_zp_3(self):
       # 128 -> $c6, DEC -> 127
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('dec aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 127, False, False)

   def test_dec_abs_1(self):
       # 1 -> $07e8, DEC -> 0, Zero-Flag
       self.cpu.addcmd('ldx #', 1)
       self.cpu.addcmd2('stx aaaa', 0x07e8)
       self.cpu.addcmd2('dec aaaa', 0x07e8)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0x07e8, 0, False, True)

   def test_dec_abs_2(self):
       # 0 -> $07e8, DEC -> 255, N-Flag
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd2('stx aaaa', 0x07e8)
       self.cpu.addcmd2('dec aaaa', 0x07e8)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0x07e8, 255, True, False)

   def test_dec_abs_3(self):
       # 128 -> $07e8, DEC -> 127
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd2('stx aaaa', 0x07e8)
       self.cpu.addcmd2('dec aaaa', 0x07e8)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0x07e8, 127, False, False)

   def test_dex_1(self):
       # 1 - 1 -> 0, Zero-Flag
       self.cpu.addcmd('ldx #', 1)
       self.cpu.addcmd('dex')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, False)

   def test_dex_2(self):
       # 0 - 1 -> 255, N-Flag
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('dex')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(255, True, False, False)

   def test_dex_3(self):
       # 128 - 1 -> 127
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd('dex')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(127, False, False, False)

   def test_dey_1(self):
       # 1 - 1 -> 0, Zero-Flag
       self.cpu.addcmd('ldy #', 1)
       self.cpu.addcmd('dey')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(0, False, True, False)

   def test_dey_2(self):
       # 0 - 1 -> 255, N-Flag
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('dey')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(255, True, False, False)

   def test_dey_3(self):
       # 128 -1 -> 127
       self.cpu.addcmd('ldy #', 128)
       self.cpu.addcmd('dey')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(127, False, False, False)

   def test_inc_zp_1(self):
       # 254 -> $c6, INC -> 255, Neg-Flag
       self.cpu.addcmd('ldx #', 254)
       self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('inc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 255, True, False)

   def test_inc_zp_2(self):
       # 255 -> $c6, INC -> 0, Zero-Flag
       self.cpu.addcmd('ldx #', 255)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('inc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 0, False, True)

   def test_inc_zp_3(self):
       # 0 -> $c6, INC -> 1
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('inc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 1, False, False)

   def test_inc_abs_1(self):
       # 254 -> $07e8, INC -> 255, Neg-Flag
       self.cpu.addcmd('ldx #', 254)
       self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
       self.cpu.addcmd2('stx aaaa', 0x07e8)
       self.cpu.addcmd2('inc aaaa', 0x07e8)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0x07e8, 255, True, False)

   def test_inc_abs_2(self):
       # 255 -> $07e8, INC -> 0, Zero-Flag
       self.cpu.addcmd('ldx #', 255)
       self.cpu.addcmd2('stx aaaa', 0x07e8)
       self.cpu.addcmd2('inc aaaa', 0x07e8)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0x07e8, 0, False, True)

   def test_inc_abs_3(self):
       # 0 -> $07e8, INC -> 1
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd2('stx aaaa', 0x07e8)
       self.cpu.addcmd2('inc aaaa', 0x07e8)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0x07e8, 1, False, False)

   def test_eor_imm_1(self):
       #   1000 1000   136
       # ^ 0101 1010    90
       # = 1101 0010   210
       self.cpu.addcmd('lda #', 136)
       self.cpu.addcmd('eor #', 90)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(210, True, False, False)

   def test_eor_imm_2(self):
       #   1111 0000   240
       # | 1111 1111    15
       # = 0000 1111   255
       self.cpu.addcmd('lda #', 240)
       self.cpu.addcmd('eor #', 255)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(15, False, False, False)

   def test_inx_1(self):
       # 254 + 1 -> 255, Neg-Flag
       self.cpu.addcmd('ldx #', 254)
       self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(255, True, False, False)

   def test_inx_2(self):
       # 255 + 1 -> 0, Zero-Flag
       self.cpu.addcmd('ldx #', 255)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, False)

   def test_inx_3(self):
       # 0 + 1 -> 1
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('inx')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(1, False, False, False)

   def test_iny_1(self):
       # 254 + 1 -> 255, Neg-Flag
       self.cpu.addcmd('ldy #', 254)
       self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
       self.cpu.addcmd('iny')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(255, True, False, False)

   def test_iny_2(self):
       # 255 + 1 -> 0, Zero-Flag
       self.cpu.addcmd('ldy #', 255)
       self.cpu.addcmd('iny')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(0, False, True, False)

   def test_iny_3(self):
       # 0 + 1 -> 1
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('iny')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(1, False, False, False)

   def test_jmp_abs(self):
       # PC -> $7010
       self.cpu.addcmd2('jmp aaaa', 0x7010)
       self.run_test()
       # PC steht auf $7011, da der brk-Befehl noch
       # ausgefuehrt wird
       self.assertEqual(self.cpu.pc, 0x7011)

   def test_jmp_ind(self):
       # $8010/$8011 = $7010; PC -> ($8010)
       self.cpu.addcmd('lda #', 0x10)
       self.cpu.addcmd2('sta aaaa', 0x8010)
       self.cpu.addcmd('lda #', 0x70)
       self.cpu.addcmd2('sta aaaa', 0x8011)
       self.cpu.addcmd2('jmp (aaaa)', 0x8010)
       self.run_test()
       # PC steht auf $7011, da der brk-Befehl noch
       # ausgefuehrt wird
       self.assertEqual(self.cpu.pc, 0x7011)

   def test_jsr_rts(self):
       # $7005 -> PC, 80 -> A, $7003 -> PC
       self.cpu.addcmd2('jsr aaaa', 0x7005)
       self.cpu.addcmd('brk')
       self.cpu.addcmd('brk')
       self.cpu.addcmd('lda #', 80)
       self.cpu.addcmd('rts')
       self.run_test()
       self.check_a(80, False, False, False)
       # $7004 wegen brk
       self.assertEqual(self.cpu.pc, 0x7004)

   def test_jsr_alt(self):
       # Alternativer Handler bei $6000;
       # 128 -> A, Neg. gesetzt, $7005 -> PC
       def handler():
           self.cpu.reg_a = 128
           self.cpu._a_set_nz_flags()
       # Handler setzen
       self.cpu.addhandler('test', 0x6000, handler)
       self.cpu.addcmd('lda #', 0)
       self.cpu.addcmd2('jsr aaaa', 0x6000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)
       # $7006 wegen brk
       self.assertEqual(self.cpu.pc, 0x7006)

   def test_lda_imm_1(self):
       # 0 -> A, Zero-Flag
       self.cpu.addcmd('lda #', 0)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, False)

   def test_lda_imm_2(self):
       # 100 -> A
       self.cpu.addcmd('lda #', 100)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(100, False, False, False)

   def test_lda_imm_3(self):
       # 128 -> A, Neg-Flag
       self.cpu.addcmd('lda #', 128)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_lda_zp(self):
       # 192 -> $61 -> A
       self.cpu.addcmd('ldx #', 192)
       self.cpu.addcmd('stx aa', 97)
       self.cpu.addcmd('lda aa', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(192, True, False, False)

   def test_lda_zp_x(self):
       # 128 -> $c6; X=4; $c6,X -> A
       self.cpu.addcmd('ldy #', 128)
       self.cpu.addcmd('sty aa', 0xca)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('lda aa,x', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_lda_abs(self):
       # 128 -> $0424 -> A
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd('stx aaaa', 36, 4)
       self.cpu.addcmd('lda aaaa', 36, 4)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_lda_abs_x(self):
       # 128 -> $0424; X=4; $0424,X -> A
       self.cpu.addcmd('ldy #', 128)
       self.cpu.addcmd2('sty aaaa', 0x0428)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd2('lda aaaa,x', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_lda_abs_y(self):
       # 128 -> $0424; Y=4; $0424,Y -> A
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd2('stx aaaa', 0x0428)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd2('lda aaaa,y', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_lda_ind_y(self):
       # 128 -> $0428; $0424 -> $61/62; Y=4; ($61/62),Y -> A
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd('stx aaaa', 40, 4)
       self.cpu.addcmd('ldx #', 0x24)
       self.cpu.addcmd('stx aa', 97)
       self.cpu.addcmd('ldx #', 0x04)
       self.cpu.addcmd('stx aa', 98)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('lda (aa),y', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_ldx_imm_1(self):
       # 0 -> X, Zero-Flag
       self.cpu.addcmd('ldx #', 0)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(0, False, True, False)

   def test_ldx_imm_2(self):
       # 100 -> X
       self.cpu.addcmd('ldx #', 100)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(100, False, False, False)

   def test_ldx_imm_3(self):
       # 128 -> X, Neg-Flag
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(128, True, False, False)

   def test_ldx_zp(self):
       # 192 -> $61 -> X
       self.cpu.addcmd('lda #', 192)
       self.cpu.addcmd('sta aa', 97)
       self.cpu.addcmd('ldx aa', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(192, True, False, False)

   def test_ldx_abs(self):
       # 128 -> $0424 -> X
       self.cpu.addcmd('lda #', 128)
       self.cpu.addcmd2('sta aaaa', 0x0424)
       self.cpu.addcmd2('ldx aaaa', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(128, True, False, False)

   def test_ldy_imm_1(self):
       # 0 -> Y, Zero-Flag
       self.cpu.addcmd('ldy #', 0)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(0, False, True, False)

   def test_ldy_imm_2(self):
       # 100 -> Y
       self.cpu.addcmd('ldy #', 100)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(100, False, False, False)

   def test_ldy_imm_3(self):
       # 128 -> Y, Neg-Flag
       self.cpu.addcmd('ldy #', 128)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(128, True, False, False)

   def test_ldy_zp(self):
       # 192 -> $61 -> Y
       self.cpu.addcmd('lda #', 192)
       self.cpu.addcmd('sta aa', 97)
       self.cpu.addcmd('ldy aa', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(192, True, False, False)

   def test_ldy_abs(self):
       # 128 -> $0424 -> Y
       self.cpu.addcmd('lda #', 128)
       self.cpu.addcmd2('sta aaaa', 0x0424)
       self.cpu.addcmd2('ldy aaaa', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(128, True, False, False)

   def test_lsr_1(self):
       #    0101 0101   85
       # >> 0010 1010   42 und Carry gesetzt
       self.cpu.addcmd('lda #', 85)
       self.cpu.addcmd('lsr A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(42, False, False, True)

   def test_lsr_2(self):
       #    0010 1010   42
       # >> 0001 0101  21
       self.cpu.addcmd('lda #', 42)
       self.cpu.addcmd('lsr A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(21, False, False, False)

   def test_lsr_zp_1(self):
       #    0101 0101   85
       # >> 0010 1010   42 und Carry gesetzt
       self.cpu.addcmd('lda #', 85)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('lsr aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 42, False, False)
       self.assertTrue(self.cpu.flag_c)

   def test_lsr_zp_2(self):
       #    0010 1010   42
       # >> 0001 0101  21
       self.cpu.addcmd('lda #', 42)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('lsr aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 21, False, False)
       self.assertFalse(self.cpu.flag_c)

   def test_nop(self):
       self.cpu.addcmd('lda #', 1)
       for i in range(5):
           self.cpu.addcmd('nop')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(1, False, False, False)

   def test_ora_imm_1(self):
       #   1000 1000   136
       # | 0101 1010    90
       # = 1101 1010   218
       self.cpu.addcmd('lda #', 136)
       self.cpu.addcmd('ora #', 90)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(218, True, False, False)

   def test_ora_imm_2(self):
       #   1111 0000   240
       # | 0000 1111    15
       # = 1111 1111   255
       self.cpu.addcmd('lda #', 240)
       self.cpu.addcmd('ora #', 15)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(255, True, False, False)

   def test_pha_pla(self):
       # 128 -> ST -> A, Neg-Flag
       self.cpu.addcmd('lda #', 128)
       self.cpu.addcmd('pha')
       self.cpu.addcmd('lda #', 0)
       self.cpu.addcmd('pla')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)
       self.assertEqual(self.cpu.sp, 255)

   def test_php_plp_1(self):
       # 128 -> Neg-Flag -> ST -> Neg-Flag
       self.cpu.addcmd('lda #', 128)
       self.cpu.addcmd('php')
       self.cpu.addcmd('lda #', 0)
       self.cpu.addcmd('plp')
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertTrue(self.cpu.flag_n)
       self.assertEqual(self.cpu.sp, 255)

   def test_php_plp_2(self):
       # 0 -> Zero-Flag -> ST -> Zero-Flag
       self.cpu.addcmd('lda #', 0)
       self.cpu.addcmd('php')
       self.cpu.addcmd('lda #', 1)
       self.cpu.addcmd('plp')
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertTrue(self.cpu.flag_z)
       self.assertEqual(self.cpu.sp, 255)

   def test_php_plp_3(self):
       # Carry-Flag -> ST -> Carry-Flag
       self.cpu.addcmd('sec')
       self.cpu.addcmd('php')
       self.cpu.addcmd('clc')
       self.cpu.addcmd('plp')
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertTrue(self.cpu.flag_c)
       self.assertEqual(self.cpu.sp, 255)

   def test_php_plp_4(self):
       # Interrupt-Flag -> ST -> Interrupt-Flag
       self.cpu.addcmd('sei') # eigentlich nicht noetig
       self.cpu.addcmd('php')
       self.cpu.addcmd('cli')
       self.cpu.addcmd('plp')
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertTrue(self.cpu.flag_i)
       self.assertEqual(self.cpu.sp, 255)

   def test_rol_1(self):
       #    1010 1010  170
       # << 0101 0100   84 und Carry gesetzt
       self.cpu.addcmd('lda #', 170)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('rol A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(84, False, False, True)

   def test_rol_2(self):
       #    0101 0100   84
       # << 1010 1000  168
       self.cpu.addcmd('lda #', 84)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('rol A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(168, True, False, False)

   def test_rol_3(self):
       #    1010 1010  170 + Carry
       # << 0101 0101   85 und Carry gesetzt
       self.cpu.addcmd('lda #', 170)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('rol A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(85, False, False, True)

   def test_rol_4(self):
       #    0101 0100   84 + Carry
       # << 1010 1001  169
       self.cpu.addcmd('lda #', 84)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('rol A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(169, True, False, False)

   def test_rol_zp_1(self):
       #    1010 1010  170
       # << 0101 0100   84 und Carry gesetzt
       self.cpu.addcmd('lda #', 170)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('rol aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 84, False, False)
       self.assertTrue(self.cpu.flag_c)

   def test_rol_zp_2(self):
       #    0101 0100   84
       # << 1010 1000  168
       self.cpu.addcmd('lda #', 84)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('rol aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 168, True, False)
       self.assertFalse(self.cpu.flag_c)

   def test_rol_zp_3(self):
       #    1010 1010  170 + Carry
       # << 0101 0100   85 und Carry gesetzt
       self.cpu.addcmd('lda #', 170)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('rol aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 85, False, False)
       self.assertTrue(self.cpu.flag_c)

   def test_rol_zp_4(self):
       #    0101 0100   84 + Carry
       # << 1010 1000  169
       self.cpu.addcmd('lda #', 84)
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('rol aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 169, True, False)
       self.assertFalse(self.cpu.flag_c)

   def test_ror_1(self):
       #    0101 0101   85
       # >> 0010 1010   42 und Carry gesetzt
       self.cpu.addcmd('lda #', 85)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('ror A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(42, False, False, True)

   def test_ror_2(self):
       #    0010 1010   42
       # >> 0001 0101   21
       self.cpu.addcmd('lda #', 42)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('ror A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(21, False, False, False)

   def test_ror_3(self):
       #    0101 0101   85 + Carry
       # >> 1010 1010  170 und Carry gesetzt
       self.cpu.addcmd('lda #', 85)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('ror A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(170, True, False, True)

   def test_ror_4(self):
       #    0010 1010   42 + Carry
       # >> 1001 0101  149
       self.cpu.addcmd('lda #', 42)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('ror A')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(149, True, False, False)

   def test_ror_zp_1(self):
       #    0101 0101   85
       # >> 0010 1010   42 und Carry gesetzt
       self.cpu.addcmd('lda #', 85)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ror aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 42, False, False)
       self.assertTrue(self.cpu.flag_c)

   def test_ror_zp_2(self):
       #    0010 1010   42
       # >> 0001 0101   21
       self.cpu.addcmd('lda #', 42)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ror aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 21, False, False)
       self.assertFalse(self.cpu.flag_c)

   def test_ror_zp_3(self):
       #    0101 0101   85 + Carry
       # >> 1010 1010  170 und Carry gesetzt
       self.cpu.addcmd('lda #', 85)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ror aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 170, True, False)
       self.assertTrue(self.cpu.flag_c)

   def test_ror_zp_4(self):
       #    0010 1010   42 + Carry
       # >> 1001 0101  149
       self.cpu.addcmd('lda #', 42)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('sta aa', 0xc6)
       self.cpu.addcmd('ror aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_mem(0xc6, 149, True, False)
       self.assertFalse(self.cpu.flag_c)

   def test_sta_zp(self):
       # 80 -> $61
       self.cpu.addcmd('lda #', 80)
       self.cpu.addcmd('sta aa', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[97], 80)

   def test_sbc_imm_1(self):
       # 36 - 21 = 15 und Carry gesetzt
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc #', 21)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(15, False, False, True)

   def test_sbc_imm_2(self):
       # 36 - 21 - Carry = 14 und Carry gesetzt
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc #', 21)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(14, False, False, True)

   def test_sbc_imm_3(self):
       # 36 - 36 = 0 und Carry und Zero gesetzt
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc #', 36)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_sbc_imm_4(self):
       # 36 - 37 = -1 = $ff und Carry geloescht, Neg gesetzt
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc #', 37)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0xff, True, False, False)

   def test_sbc_zp_1(self):
       # [aa] = 21; 36 - [aa] = 15 und Carry gesetzt
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(15, False, False, True)

   def test_sbc_zp_2(self):
       # [aa] = 21; 36 - [aa] - Carry = 14 und Carry gesetzt
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(14, False, False, True)

   def test_sbc_zp_3(self):
       # [aa] = 36; 36 - [aa] = 0 und Carry und Zero gesetzt
       self.cpu.addcmd('ldx #', 36)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_sbc_zp_4(self):
       # [aa] = 37; 36 - [aa] = -1 = $ff und Carry geloescht, Neg gesetzt
       self.cpu.addcmd('ldx #', 37)
       self.cpu.addcmd('stx aa', 0xc6)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd('sbc aa', 0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0xff, True, False, False)

   def test_sbc_abs_1(self):
       # [aaaa] = 21; 36 - [aaaa] = 15 und Carry gesetzt
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(15, False, False, True)

   def test_sbc_abs_2(self):
       # [aaaa] = 21; 36 - [aaaa] - Carry = 14 und Carry gesetzt
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(14, False, False, True)

   def test_sbc_abs_3(self):
       # [aaaa] = 36; 36 - [aaaa] = 0 und Carry und Zero gesetzt
       self.cpu.addcmd('ldx #', 36)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_sbc_abs_4(self):
       # [aaaa] = 37; 36 - [aaaa] = -1 = $ff und Carry geloescht, Neg gesetzt
       self.cpu.addcmd('ldx #', 37)
       self.cpu.addcmd2('stx aaaa', 0x2000)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0xff, True, False, False)

   def test_sbc_abs_x_1(self):
       # [aaaa,x] = 21; 36 - [aaaa,x] = 15 und Carry gesetzt
       self.cpu.addcmd('ldy #', 21)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(15, False, False, True)

   def test_sbc_abs_x_2(self):
       # [aaaa,x] = 21; 36 - [aaaa,x] - Carry = 14 und Carry gesetzt
       self.cpu.addcmd('ldy #', 21)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(14, False, False, True)

   def test_sbc_abs_x_3(self):
       # [aaaa,x] = 36; 36 - [aaaa,x] = 0 und Carry und Zero gesetzt
       self.cpu.addcmd('ldy #', 36)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_sbc_abs_x_4(self):
       # [aaaa,x] = 37; 36 - [aaaa,x] = -1 = $ff und Carry geloescht, Neg gesetzt
       self.cpu.addcmd('ldy #', 37)
       self.cpu.addcmd2('sty aaaa', 0x2004)
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,x', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0xff, True, False, False)

   def test_sbc_abs_y_1(self):
       # [aaaa,y] = 21; 36 - [aaaa,y] = 15 und Carry gesetzt
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(15, False, False, True)

   def test_sbc_abs_y_2(self):
       # [aaaa,y] = 21; 36 - [aaaa,y] - Carry = 14 und Carry gesetzt
       self.cpu.addcmd('ldx #', 21)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('clc')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(14, False, False, True)

   def test_sbc_abs_y_3(self):
       # [aaaa,y] = 36; 36 - [aaaa,y] = 0 und Carry und Zero gesetzt
       self.cpu.addcmd('ldx #', 36)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0, False, True, True)

   def test_sbc_abs_y_4(self):
       # [aaaa,y] = 37; 36 - [aaaa,y] = -1 = $ff und Carry geloescht, Neg gesetzt
       self.cpu.addcmd('ldx #', 37)
       self.cpu.addcmd2('stx aaaa', 0x2004)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('sec')
       self.cpu.addcmd('lda #', 36)
       self.cpu.addcmd2('sbc aaaa,y', 0x2000)
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(0xff, True, False, False)

   def test_sta_zp_x(self):
       # X=4; 65 -> $c6,X
       self.cpu.addcmd('ldx #', 4)
       self.cpu.addcmd('lda #', 65)
       self.cpu.addcmd('sta aa,x',0xc6)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[0xca], 65)

   def test_sta_abs(self):
       # 65 -> $0424
       self.cpu.addcmd('lda #', 65)
       self.cpu.addcmd2('sta aaaa', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[0x0424], 65)

   def test_sta_abs_x(self):
       # X=16; 65 -> $0424,X
       self.cpu.addcmd('ldx #', 16)
       self.cpu.addcmd('lda #', 65)
       self.cpu.addcmd2('sta aaaa,x', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[0x0434], 65)

   def test_sta_abs_y(self):
       # Y=16; 65 -> $0424,Y
       self.cpu.addcmd('ldy #', 16)
       self.cpu.addcmd('lda #', 65)
       self.cpu.addcmd2('sta aaaa,y',0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[0x0434], 65)

   def test_sta_ind_y(self):
       # $0424 -> $61/62; Y=4; 65 -> ($61/62),Y
       self.cpu.addcmd('ldx #', 0x24)
       self.cpu.addcmd('stx aa', 97)
       self.cpu.addcmd('ldx #', 0x04)
       self.cpu.addcmd('stx aa', 98)
       self.cpu.addcmd('lda #', 65)
       self.cpu.addcmd('ldy #', 4)
       self.cpu.addcmd('sta (aa),y', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[0x0428], 65)

   def test_stx_zp(self):
       # 80 -> $61
       self.cpu.addcmd('ldx #', 80)
       self.cpu.addcmd('stx aa', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[97], 80)

   def test_stx_abs(self):
       # 65 -> $0424
       self.cpu.addcmd('ldx #', 65)
       self.cpu.addcmd2('stx aaaa', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[0x0424], 65)

   def test_sty_zp(self):
       # 80 -> $61
       self.cpu.addcmd('ldy #', 80)
       self.cpu.addcmd('sty aa', 97)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[97], 80)

   def test_sty_abs(self):
       # 65 -> $0424
       self.cpu.addcmd('ldy #', 65)
       self.cpu.addcmd2('sty aaaa', 0x0424)
       self.cpu.addcmd('brk')
       self.run_test()
       self.assertEqual(self.cpu.mem[0x0424], 65)

   def test_tax(self):
       # A -> X
       self.cpu.addcmd('lda #', 128)
       self.cpu.addcmd('tax')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_x(128, True, False, False)

   def test_tay(self):
       # A -> Y
       self.cpu.addcmd('lda #', 128)
       self.cpu.addcmd('tay')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_y(128, True, False, False)

   def test_txa(self):
       # X -> A
       self.cpu.addcmd('ldx #', 128)
       self.cpu.addcmd('txa')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)

   def test_tya(self):
       # Y -> A
       self.cpu.addcmd('ldy #', 128)
       self.cpu.addcmd('tya')
       self.cpu.addcmd('brk')
       self.run_test()
       self.check_a(128, True, False, False)


if __name__ == '__main__':
   unittest.main()

You are viewing proxied material from sdfeu.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.