jsbeeb 1.1.1

package/tests/integration/bcd.js

@@ -0,0 +1,23 @@
+import { describe, it } from "vitest";
+import { TestMachine } from "../test-machine.js";
+import assert from "assert";
+
+describe("test binary coded decimal behaviour", { timeout: 30000 }, function () {
+    const doTest = async (model) => {
+        const testMachine = new TestMachine(model);
+        await testMachine.initialise();
+        await testMachine.loadDisc("discs/bcdtest.ssd");
+        await testMachine.runUntilInput();
+        await testMachine.type("*BCDTEST");
+        let output = "";
+        testMachine.captureText((elem) => (output += elem.text));
+        await testMachine.runUntilInput();
+        assert(output.indexOf("PASSED") >= 0, `Failed with ${output}`);
+    };
+    it("should match on 65C12", async () => {
+        await doTest("Master");
+    });
+    it("should match on 6502", async () => {
+        await doTest();
+    });
+});

package/tests/integration/dormann.js

@@ -0,0 +1,101 @@
+"use strict";
+
+import _ from "underscore";
+import { describe, it } from "vitest";
+import * as utils from "../../src/utils.js";
+import { fake6502, fake65C02, fake65C12 } from "../../src/fake6502.js";
+
+import assert from "assert";
+
+const log = false;
+
+async function runTest(processor, test, name) {
+    const base = "tests/6502_65C02_functional_tests/bin_files/" + test;
+
+    function parseSuccess(listing) {
+        let expectedPc = null;
+        let next = false;
+        let successRe = /^\s*success\b\s*(;.*)?$/;
+        _.each(listing.split("\n"), function (line) {
+            if (next) {
+                next = false;
+                expectedPc = parseInt(line.match(/^([0-9a-fA-F]+)/)[1], 16);
+                console.log("Found success address $" + utils.hexword(expectedPc));
+            } else {
+                next = !!line.match(successRe);
+            }
+        });
+        if (expectedPc === null) throw "Unable to parse";
+        return expectedPc;
+    }
+
+    const expectedPc = parseSuccess((await utils.loadData(base + ".lst")).toString());
+    const data = await utils.loadData(base + ".bin");
+    for (let i = 0; i < data.length; ++i) processor.writemem(i, data[i]);
+
+    processor.pc = 0x400;
+    processor.debugInstruction.add(function (addr) {
+        if (log) {
+            console.log(
+                utils.hexword(addr) +
+                    " : A=" +
+                    utils.hexbyte(processor.a) +
+                    " : X=" +
+                    utils.hexbyte(processor.x) +
+                    " : Y=" +
+                    utils.hexbyte(processor.y) +
+                    " : " +
+                    processor.disassembler.disassemble(processor.pc)[0],
+            );
+        }
+
+        // Stop once we get stuck at the same address.
+        return addr === processor.getPrevPc(1);
+    });
+    console.log("Running Dormann " + name + " tests...");
+    processor.execute(2000000 * 60);
+    console.log(`Run complete at $${utils.hexword(processor.pc)}`);
+    const result = processor.pc === expectedPc;
+    if (!result) logFailure(processor);
+    return result;
+}
+
+function logFailure(processor) {
+    console.log("Failed at " + utils.hexword(processor.pc));
+    console.log("Previous PCs:");
+    for (let i = 1; i < 16; ++i) {
+        console.log("  " + utils.hexword(processor.getPrevPc(i)));
+    }
+    console.log("A: " + utils.hexbyte(processor.a));
+    console.log("X: " + utils.hexbyte(processor.x));
+    console.log("Y: " + utils.hexbyte(processor.y));
+    console.log("S: " + utils.hexbyte(processor.s));
+    console.log("P: " + utils.hexbyte(processor.p.asByte()) + " " + processor.p.debugString());
+    console.log(
+        utils.hd(
+            function (i) {
+                return processor.readmem(i);
+            },
+            0x00,
+            0x40,
+        ),
+    );
+}
+
+describe("dormann tests", { timeout: 30000 }, function () {
+    it("should pass 6502 functional tests", async () => {
+        const cpu = fake6502();
+        await cpu.initialise();
+        assert(await runTest(cpu, "6502_functional_test", "6502"));
+    });
+    it("should pass 65c02 extended opcode tests", async () => {
+        const cpu = fake65C02();
+        await cpu.initialise();
+        assert(await runTest(cpu, "65C02_extended_opcodes_test", "65C02"));
+    });
+    it("should pass 65c12 extended opcode tests", async () => {
+        const cpu = fake65C12();
+        await cpu.initialise();
+        assert(await runTest(cpu, "65C12_extended_opcodes_test", "65C12"));
+    });
+});

package/tests/integration/dp111timing.js

@@ -0,0 +1,42 @@
+import { describe, it } from "vitest";
+import { TestMachine } from "../test-machine.js";
+import assert from "assert";
+
+describe("test dp111's timing tests", { timeout: 30000 }, function () {
+    const doTest = async (disc, machine) => {
+        const testMachine = new TestMachine(machine);
+        await testMachine.initialise();
+        await testMachine.loadDisc(`tests/integration/dp111_6502Timing/${disc}.ssd`);
+        await testMachine.runUntilInput();
+        let output = "";
+        testMachine.captureText((elem) => {
+            output += `${elem.text}\n`;
+        });
+        await testMachine.type("*RUN 6502TIM");
+        let numFailedTests = null;
+        const hook = testMachine.processor.debugWrite.add((addr, value) => {
+            if (addr === 0xfcd0) {
+                numFailedTests = value;
+            }
+        });
+        await testMachine.runUntilInput();
+        hook.remove();
+        if (numFailedTests) {
+            console.log(`Test failed, output:\n${output}`);
+        }
+        assert.equal(numFailedTests, 0);
+    };
+    it("should handle 6502timing", async () => {
+        await doTest("6502timing");
+    });
+    it("should handle 6502timing with 1MHz bus", async () => {
+        await doTest("6502timing1M");
+    });
+
+    it("should handle 65C12timing", async () => {
+        await doTest("65C12timing", "Master");
+    });
+    it("should handle 65C12timing with 1MHz bus", async () => {
+        await doTest("65C12timing1M", "Master");
+    });
+});

package/tests/integration/ensure-submodules.js

@@ -0,0 +1,25 @@
+import { describe, it } from "vitest";
+import assert from "assert";
+import * as fs from "fs";
+
+describe("ensure git submodules are present", function () {
+    it("should have functional tests", function () {
+        try {
+            fs.accessSync("tests/6502_65C02_functional_tests/README.md");
+        } catch {
+            assert.fail(
+                "Functional tests submodule missing. Ensure git submodules are fetched (git submodule update --init).",
+            );
+        }
+    });
+
+    it("should have timing tests", function () {
+        try {
+            fs.accessSync("tests/integration/dp111_6502Timing/README.md");
+        } catch {
+            assert.fail(
+                "Timing tests submodule missing. Ensure git submodules are fetched  (git submodule update --init).",
+            );
+        }
+    });
+});

package/tests/integration/nops.bas

@@ -0,0 +1,119 @@
+1REM Thanks to Tom Seddon!
+10REM>NOPS
+20MODE1
+30PRINX%=0:PRINY%=0:COLWIDTH%=0
+40CODESIZE%=1000:DIMCODE%CODESIZE%
+50:
+60FORPASS%=0TO2STEP2:P%=CODE%:[OPTPASS%
+70LDA&60:PHA
+80LDA#0:STA&60
+90JSRSMBTEST
+100LDA&60:STA&70
+110PLA:STA&60
+120RTS
+130:
+140.SMBTEST
+150EQUB&87:EQUB&60:\SMB0 &60
+160RTS
+170]
+180NEXT
+190CALLCODE%
+200ROCKWELL%=?&70<>0
+210IFROCKWELL%:PROCPRINT(3,0,"ROCKWELL/WDC CPU"):ELSE:PROCPRINT(3,0,"CMOS CPU")
+220PROCPRINT(0,1,"2 CYCLES")
+230T2C%=FNTIME(1,&EA,1,-1)
+240PROCPRINT(0,1,"3 CYCLES")
+250T3C%=FNTIME(1,&A5,2,-1)
+260PROCPRINT(0,1,"4 CYCLES")
+270T4C%=FNTIME(1,&AD,3,-1)
+271PROCPRINT(0,1,"8 CYCLES")
+272T8C%=FNTIME(2,&AD,3,-1)
+273PROCPRINT(0,1,"1 CYCLES")
+274T1C%=T2C%-INT(((T3C%-T2C%)+(T4C%-T2C%)/2+(T8C%-T2C%)/6)/3)
+275PROCPRINT(0,3,"GUESS: "+STR$T1C%)
+280RESTORE560:PROCMULTI(T2C%,2,2)
+290RESTORE580:PROCMULTI(T3C%,3,2)
+300RESTORE620:PROCMULTI(T4C%,4,2)
+310RESTORE680:PROCMULTI(T8C%,8,3)
+320RESTORE410:PROCMULTI(-1,1,1)
+330IFNOTROCKWELL%:RESTORE440:PROCMULTI(-1,1,1)
+340RESTORE470:PROCMULTI(-1,1,1)
+350IFNOTROCKWELL%:RESTORE500:PROCMULTI(-1,1,1)
+360IFNOTROCKWELL%:RESTORE530:PROCMULTI(-1,1,1)
+370END
+380:
+390:
+400REM 1 CYCLES, 1 BYTES
+410DATA &03,&13,&23,&33,&43,&53,&63,&73,&83,&93,&A3,&B3,&C3,&D3,&E3,&F3,-1
+420:
+430REM 1 CYCLES, 1 BYTES (NOT ROCKWELL)
+440DATA &07,&17,&27,&37,&47,&57,&67,&77,&87,&97,&A7,&B7,&C7,&D7,&E7,&F7,-1
+450:
+460REM 1 CYCLES, 1 BYTES
+470DATA &0B,&1B,&2B,&3B,&4B,&5B,&6B,&7B,&8B,&9B,&AB,&BB,&EB,&FB,-1
+480:
+490REM 1 CYCLES, 1 BYTES (NOT WDC)
+500DATA &CB,&DB,-1
+510:
+520REM 1 CYCLES, 1 BYTES (NOT ROCKWELL)
+530DATA &0F,&1F,&2F,&3F,&4F,&5F,&6F,&7F,&8F,&9F,&AF,&BF,&CF,&DF,&EF,&FF,-1
+540:
+550REM 2 CYCLES, 2 BYTES
+560DATA &02,&22,&42,&62,&82,&C2,&E2,-1
+570:
+580REM 3 CYCLES, 2 BYTES
+590DATA &44,-1
+600:
+610REM 4 CYCLES, 2 BYTES
+620DATA &54,&D4,&F4,-1
+630:
+640REM 4 CYCLES, 3 BYTES
+650DATA &DC,&FC,-1
+660:
+670REM 8 CYCLES, 3 BYTES
+680DATA &5C,-1
+690:
+700DEFPROCMULTI(TEXPECTED%,NC%,NB%)
+710PROCPRINT(0,2,STR$NC%+" CYCLES")
+720REPEAT
+730READNOP%:IFNOP%=-1:GOTO750
+740T%=FNTIME(1,NOP%,NB%,TEXPECTED%)
+750UNTILNOP%=-1
+760ENDPROC
+770:
+780DEFFNTIME(NCOPIES%,NOP%,N%,TEXPECTED%)
+790IFN%<1ORN%>3:STOP
+800FORPASS%=0TO2STEP2:P%=CODE%:[OPTPASS%
+810.START
+820LDX#0
+830.XLOOP
+840LDY#0
+850.YLOOP
+860]
+870FORI%=1TONCOPIES%*10
+880[OPTPASS%:EQUBNOP%:]
+890IFN%>=2:[OPTPASS%:EQUB0:]
+900IFN%>=3:[OPTPASS%:EQUB0:]
+910NEXT
+920[OPTPASS%
+930DEY:BNEYLOOP
+940DEX:BNEXLOOP
+950RTS
+960]IFP%>CODE%+CODESIZE%:STOP
+970NEXT
+980TIME=0
+990REMPRINTFNHEX2(NOP%)" (";N%"): ";
+1000CALLSTART
+1010T%=TIME
+1020IFTEXPECTED%>=0ANDABS(TIME-TEXPECTED%)>2:B%=1:ELSE:B%=0
+1030PROCPRINT(B%,3,FNHEX2(NOP%)+" ("+STR$N%+"): "+STR$T%)
+1040=T%
+1050DEFFNHEX2(X%)=RIGHT$("0"+STR$~X%,2)
+1060DEFPROCPRINT(B%,F%,MSG$)
+1070COLOUR128+B%:COLOURF%
+1080PRINTTAB(PRINX%,PRINY%);MSG$;
+1090COLOUR128:COLOUR7
+1100IFLENMSG$>COLWIDTH%:COLWIDTH%=LENMSG$
+1110PRINY%=PRINY%+1
+1120IFPRINY%=32:PRINY%=0:PRINX%=PRINX%+COLWIDTH%+1:COLWIDTH%=0
+1130ENDPROC

package/tests/integration/nops.js

@@ -0,0 +1,24 @@
+import { describe, it } from "vitest";
+import assert from "assert";
+import * as utils from "../../src/utils.js";
+import { TestMachine } from "../test-machine.js";
+
+describe("test various NOP timings", { timeout: 30000 }, function () {
+    it("should match the nops.bas code", async () => {
+        const testMachine = new TestMachine("Master");
+        await testMachine.initialise();
+        await testMachine.runUntilInput();
+        const data = await utils.loadData("tests/integration/nops.bas");
+        await testMachine.loadBasic(utils.uint8ArrayToString(data));
+
+        let numCaptures = 0;
+        testMachine.captureText((elem) => {
+            assert(elem.background !== 1, `Failure from test - ${JSON.stringify(elem)}`);
+            console.log(`emulator output: ${elem.text}`);
+            numCaptures++;
+        });
+        await testMachine.type("RUN");
+        await testMachine.runUntilInput(2 * 60);
+        assert(numCaptures === 97, "Missing output");
+    });
+});

package/tests/integration/protection.js

@@ -0,0 +1,26 @@
+import { describe, it } from "vitest";
+import { TestMachine } from "../test-machine.js";
+
+describe("test Kevin Edwards' gnarly protection system", { timeout: 10000 }, function () {
+    const doTest = async (name) => {
+        const testMachine = new TestMachine();
+        await testMachine.initialise();
+        await testMachine.loadDisc("discs/Protection.ssd");
+        await testMachine.runUntilInput();
+        await testMachine.type(`CHAIN "B.${name}"`);
+        const hook = testMachine.processor.debugInstruction.add((addr) => {
+            return addr === 0xfff4 && testMachine.processor.a === 200 && testMachine.processor.x === 3;
+        });
+        await testMachine.runUntilAddress(0xe00, 20);
+        hook.remove();
+    };
+    it("should decode Alien8", async () => {
+        await doTest("ALIEN8");
+    });
+    it("should decode Nightshade", async () => {
+        await doTest("NIGHTSH");
+    });
+    it("should decode Lunar Jetman", async () => {
+        await doTest("JETMAN");
+    });
+});

package/tests/integration/rmw.js

@@ -0,0 +1,69 @@
+import * as utils from "../../src/utils.js";
+import { describe, it } from "vitest";
+import { TestMachine } from "../test-machine.js";
+import assert from "assert";
+
+describe("test read-modify-write behaviour", function () {
+    const doTest = async (model) => {
+        const testMachine = new TestMachine(model);
+        await testMachine.initialise();
+        await testMachine.loadDisc("discs/RmwX.ssd");
+        await testMachine.runUntilInput();
+        await testMachine.type("*TIMINGS");
+        await testMachine.runUntilInput();
+        let result = "";
+        for (let i = 0x100; i < 0x110; i += 4) {
+            if (i !== 0x100) result += " ";
+            for (let j = 3; j >= 0; --j) {
+                result += utils.hexbyte(testMachine.readbyte(i + j));
+            }
+        }
+        return result;
+    };
+    it("should match on 65C12", async () => {
+        const result = await doTest("Master");
+        assert.strictEqual(result, "f4ff0a16 eaeadee9 f2fe0a16 c3ced9e5");
+    });
+    it("should match on 6502", async () => {
+        const result = await doTest();
+        assert.strictEqual(result, "f2fe0a16 eaeadae6 f2fe0a16 c1cdd9e5");
+    });
+});
+
+describe("should pass scarybeasts' RMW test on master", function () {
+    it("should match", async function () {
+        // https://stardot.org.uk/forums/viewtopic.php?f=4&t=23131
+        const source = `
+P%=&2000
+[OPT0
+SEI
+LDA #0:STA &FE68
+LDA #1:STA &FE69
+LDA #&7F:STA &FE6D
+LDA #1:STA &FE68
+LDA #0:STA &FE69
+DEC &FE68
+LDA &FE6D
+AND #&20
+STA &71
+LDA #0:STA &FE69
+LDA &FE68
+STA &70
+CLI
+RTS
+]
+?&70=0
+?&71=0
+CALL &2000`;
+        const testMachine = new TestMachine("Master");
+        await testMachine.initialise();
+        await testMachine.runUntilInput();
+        await testMachine.loadBasic(source);
+
+        testMachine.captureText((elem) => console.log(`emulator output: ${elem.text}`));
+        await testMachine.type("RUN");
+        await testMachine.runUntilInput();
+        assert.equal(testMachine.readbyte(0x70), 252);
+        assert.equal(testMachine.readbyte(0x71), 0);
+    });
+});

package/tests/integration/teletext.js

@@ -0,0 +1,126 @@
+import { describe, it } from "vitest";
+import { TestMachine } from "../test-machine.js";
+import assert from "assert";
+import { Video } from "../../src/video.js";
+import sharp from "sharp";
+import pixelmatch from "pixelmatch";
+
+class CapturingVideo extends Video {
+    constructor() {
+        super(false, new Uint32Array(1024 * 1024), () => {});
+        this.paint_ext = (left, top, right, bottom) => this._onPaint(left, top, right, bottom);
+        this._capturing = false;
+        this._captureSharp = null;
+    }
+
+    _onPaint(left, top, right, bottom) {
+        if (this._capturing) {
+            const width = right - left;
+            const height = bottom - top;
+            const bufferCopy = new Uint8Array(this.fb32.buffer.slice(0));
+            this._captureSharp = sharp(bufferCopy, {
+                raw: { width: 1024, height: 1024, channels: 4 },
+            }).extract({ left: left, top: top, width, height });
+            this._capturing = false;
+        }
+    }
+
+    async capture(testMachine) {
+        this._capturing = true;
+        await testMachine.runUntilVblank();
+        if (this._capturing) throw new Error("Should have captured by now");
+        return this._captureSharp;
+    }
+}
+
+async function setupCeefaxTestMachine(video) {
+    const testMachine = new TestMachine(null, { video: video });
+    await testMachine.initialise();
+    await testMachine.runUntilInput();
+    await testMachine.loadDisc("discs/eng_test.ssd");
+    await testMachine.type("*EXEC !BOOT");
+    await testMachine.runFor(3 * 1000 * 1000);
+    return testMachine;
+}
+
+const rootDir = "tests/integration/teletext";
+const outputDir = `tests/integration/output`;
+
+async function compare(video, testMachine, expectedName) {
+    const outputName = `${expectedName.replace("expected", "actual")}`;
+    const captureSharp = await video.capture(testMachine);
+    const outputFile = `${outputDir}/${outputName}`;
+    await captureSharp.removeAlpha().toFile(outputFile);
+    const expectedFile = `${rootDir}/${expectedName}`;
+    const diffFile = `${outputDir}/${outputName.replace(".png", ".diff.png")}`;
+
+    const { data: expectedData, info } = await sharp(expectedFile)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const actualData = await sharp(outputFile).ensureAlpha().raw().toBuffer();
+    const diffData = new Uint8Array(info.width * info.height * info.channels);
+
+    const numDiffPixels = pixelmatch(expectedData, actualData, diffData, info.width, info.height, {
+        threshold: 0.1,
+    });
+    await sharp(diffData, { raw: info }).removeAlpha().toFile(diffFile);
+    assert.equal(
+        numDiffPixels,
+        0,
+        `Images do not match - expected ${expectedFile}, got ${outputFile}, diffs: ${diffFile}}`,
+    );
+}
+
+describe("Test Ceefax test page", { timeout: 30000 }, () => {
+    it("should match the Ceefax test page (no flash)", async () => {
+        const video = new CapturingVideo();
+        const testMachine = await setupCeefaxTestMachine(video);
+        await compare(video, testMachine, `expected_flash_0.png`);
+    });
+    it("should match the Ceefax test page (flash)", async () => {
+        const video = new CapturingVideo();
+        const testMachine = await setupCeefaxTestMachine(video);
+        await testMachine.runFor(1500000);
+        await compare(video, testMachine, `expected_flash_1.png`);
+    });
+    it("should match the Ceefax test page after reveal (no flash)", async () => {
+        const video = new CapturingVideo();
+        const testMachine = await setupCeefaxTestMachine(video);
+        await testMachine.type(" ");
+        await compare(video, testMachine, `expected_reveal_flash_0.png`);
+    });
+    it("should match the Ceefax test page after reveal (flash)", async () => {
+        const video = new CapturingVideo();
+        const testMachine = await setupCeefaxTestMachine(video);
+        await testMachine.type(" ");
+        await testMachine.runFor(1500000);
+        await compare(video, testMachine, `expected_reveal_flash_1.png`);
+    });
+});
+
+describe("Test other teletext test pages", { timeout: 30000 }, () => {
+    it("should work with hoglet's test case", async () => {
+        const video = new CapturingVideo();
+        const testMachine = new TestMachine(null, { video: video });
+        await testMachine.initialise();
+        await testMachine.runUntilInput();
+        // https://github.com/mattgodbolt/jsbeeb/issues/316
+        await testMachine.type("VDU &91,&61,&9E,&92,&93,&94,&81,&91,&91,10,13");
+        await testMachine.runUntilInput();
+        await compare(video, testMachine, `expected_hoglet_held_char.png`);
+    });
+    it("should work with the alternative engineer test page bug 469", async () => {
+        const video = new CapturingVideo();
+        const testMachine = new TestMachine(null, { video: video });
+        await testMachine.initialise();
+        await testMachine.runUntilInput();
+        // https://github.com/mattgodbolt/jsbeeb/issues/469
+        // Taken from the 7th line of the engineer test page from b2.
+        await testMachine.type(
+            "CLS:VDU &81,&80,&81,&A0,&80,&A0,&81,&9E,&A0,&9E,&A0,&97,&AC,&93,&93,&96,&96,&92,&92,&92,&95,&95,&91,&91,&94,&94,&94,&A0,&A0,&94,&80,&81,&80,&81,&80,&81,&80,&81,&B0,&B7",
+        );
+        await testMachine.runUntilInput();
+        await compare(video, testMachine, `expected_bug_469.png`);
+    });
+});

package/tests/integration/timings.js

@@ -0,0 +1,56 @@
+import { describe, it } from "vitest";
+import { TestMachine } from "../test-machine.js";
+import assert from "assert";
+
+describe("test timings", function () {
+    const doTest = async (model) => {
+        const testMachine = new TestMachine(model);
+        await testMachine.initialise();
+        await testMachine.loadDisc("discs/TestTimings.ssd");
+        await testMachine.runUntilInput();
+        await testMachine.type('CHAIN "TEST"');
+        await testMachine.runUntilInput();
+        const result = [];
+        const num = testMachine.readbyte(0x71) + 1;
+        for (let i = 0; i < num; ++i) {
+            const irqAddr = (testMachine.readbyte(0x4300 + i) << 8) | testMachine.readbyte(0x4000 + i);
+            const a = testMachine.readbyte(0x4100 + i);
+            const b = testMachine.readbyte(0x4200 + i);
+            result.push([irqAddr, a, b]);
+        }
+        return result;
+    };
+    it("should match expected values", async () => {
+        const result = await doTest();
+        // prettier-ignore
+        assert.deepStrictEqual(result,
+            [
+                [0x4436, 0x00, 0xDD],
+                [0x4443, 0x00, 0xDD],
+                [0x4450, 0x00, 0xDD],
+                [0x445E, 0x00, 0xDD],
+                [0x0000, 0x00, 0x00],
+                [0x0000, 0x00, 0x00],
+                [0x4488, 0x00, 0xFF],
+                [0x4497, 0x00, 0x00],
+                [0x0000, 0x00, 0x00],
+                [0x44B8, 0xC0, 0xFF],
+                [0x44C5, 0xC0, 0xFF],
+                [0x0000, 0x00, 0x00],
+                [0x0000, 0x00, 0x00],
+                [0x44F6, 0xC0, 0xDB],
+                [0x4506, 0xC0, 0xDC],
+                [0x4516, 0xC0, 0xFF],
+                [0x4527, 0xC0, 0x00],
+                [0x453A, 0xC0, 0x01],
+                [0x454A, 0xC0, 0x01],
+                [0x4559, 0xC0, 0x00],
+                [0x4569, 0xC0, 0x00],
+                [0x4578, 0xC0, 0x01],
+                [0x458A, 0xC0, 0xFF],
+                [0x4599, 0xC0, 0x00],
+                [0x45A6, 0xC0, 0x00],
+                [0x0000, 0x00, 0x00]
+            ]);
+    });
+});