Create a gist now

Instantly share code, notes, and snippets.

What would you like to do?
Macroexpansion of defasm
(progn
(let* ((#:*opcode-meta*1641 *opcode-meta*))
(let ((#:new1640 '(adc "Add to Accumulator with Carry" 6 2 indirect-x)))
(funcall #'(setf aref) #:new1640 #:*opcode-meta*1641 97)))
(let* ((#:*opcode-meta*1643 *opcode-meta*))
(let ((#:new1642 '(adc "Add to Accumulator with Carry" 3 2 zero-page)))
(funcall #'(setf aref) #:new1642 #:*opcode-meta*1643 101)))
(let* ((#:*opcode-meta*1645 *opcode-meta*))
(let ((#:new1644 '(adc "Add to Accumulator with Carry" 2 2 immediate)))
(funcall #'(setf aref) #:new1644 #:*opcode-meta*1645 105)))
(let* ((#:*opcode-meta*1647 *opcode-meta*))
(let ((#:new1646 '(adc "Add to Accumulator with Carry" 4 3 absolute)))
(funcall #'(setf aref) #:new1646 #:*opcode-meta*1647 109)))
(let* ((#:*opcode-meta*1649 *opcode-meta*))
(let ((#:new1648 '(adc "Add to Accumulator with Carry" 5 2 indirect-y)))
(funcall #'(setf aref) #:new1648 #:*opcode-meta*1649 113)))
(let* ((#:*opcode-meta*1651 *opcode-meta*))
(let ((#:new1650 '(adc "Add to Accumulator with Carry" 4 2 zero-page-x)))
(funcall #'(setf aref) #:new1650 #:*opcode-meta*1651 117)))
(let* ((#:*opcode-meta*1653 *opcode-meta*))
(let ((#:new1652 '(adc "Add to Accumulator with Carry" 4 3 absolute-y)))
(funcall #'(setf aref) #:new1652 #:*opcode-meta*1653 121)))
(let* ((#:*opcode-meta*1655 *opcode-meta*))
(let ((#:new1654 '(adc "Add to Accumulator with Carry" 4 3 absolute-x)))
(funcall #'(setf aref) #:new1654 #:*opcode-meta*1655 125)))
(let* ((#:*opcode-funs*1657 *opcode-funs*))
(let ((#:new1656
(labels ((adc-61 (cpu)
(let* ((#:cpu1662 cpu)
(#:g1663 1)
(#:new1661 (+ (cpu-pc #:cpu1662) #:g1663)))
(funcall #'(setf cpu-pc) #:new1661 #:cpu1662))
(flet ((getter ()
(get-byte (indirect-x cpu)))
(setter (x)
(let* ((#:cpu1667 cpu))
(let ((#:new1666 x))
(funcall #'(setf indirect-x) #:new1666 #:cpu1667)))))
(let ((result
(+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1670 1) (#:g1671 0) (#:cpu1669 cpu))
(let ((#:g1672
(if (> result 255)
1
0)))
(let ((#:new1668 (dpb #:g1672 (byte #:g1670 #:g1671) (cpu-sr #:cpu1669))))
(funcall #'(setf cpu-sr) #:new1668 #:cpu1669)
#:g1672)))
(let* ((#:g1675 1) (#:g1676 6) (#:cpu1674 cpu))
(let ((#:g1677
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1673 (dpb #:g1677 (byte #:g1675 #:g1676) (cpu-sr #:cpu1674))))
(funcall #'(setf cpu-sr) #:new1673 #:cpu1674)
#:g1677)))
(let* ((#:g1680 1) (#:g1681 7) (#:cpu1679 cpu))
(let ((#:g1682
(if (logbitp 7 result)
1
0)))
(let ((#:new1678 (dpb #:g1682 (byte #:g1680 #:g1681) (cpu-sr #:cpu1679))))
(funcall #'(setf cpu-sr) #:new1678 #:cpu1679)
#:g1682)))
(let* ((#:g1685 1) (#:g1686 1) (#:cpu1684 cpu))
(let ((#:g1687
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1683 (dpb #:g1687 (byte #:g1685 #:g1686) (cpu-sr #:cpu1684))))
(funcall #'(setf cpu-sr) #:new1683 #:cpu1684)
#:g1687))))
(let* ((#:cpu1689 cpu))
(let ((#:new1688 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1688 #:cpu1689)))))
(let* ((#:cpu1691 cpu)
(#:g1692 1)
(#:new1690 (+ (cpu-pc #:cpu1691) #:g1692)))
(funcall #'(setf cpu-pc) #:new1690 #:cpu1691))
(let* ((#:cpu1694 cpu)
(#:g1695 6)
(#:new1693 (+ (cpu-cc #:cpu1694) #:g1695)))
(funcall #'(setf cpu-cc) #:new1693 #:cpu1694))))
#'adc-61)))
(funcall #'(setf aref) #:new1656 #:*opcode-funs*1657 97)))
(let* ((#:*opcode-funs*1697 *opcode-funs*))
(let ((#:new1696
(labels ((adc-65 (cpu)
(let* ((#:cpu1702 cpu)
(#:g1703 1)
(#:new1701 (+ (cpu-pc #:cpu1702) #:g1703)))
(funcall #'(setf cpu-pc) #:new1701 #:cpu1702))
(flet ((getter ()
(get-byte (zero-page cpu)))
(setter (x)
(let* ((#:cpu1707 cpu))
(let ((#:new1706 x))
(funcall #'(setf zero-page) #:new1706 #:cpu1707)))))
(let ((result (+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1710 1) (#:g1711 0) (#:cpu1709 cpu))
(let ((#:g1712
(if (> result 255)
1
0)))
(let ((#:new1708 (dpb #:g1712 (byte #:g1710 #:g1711) (cpu-sr #:cpu1709))))
(funcall #'(setf cpu-sr) #:new1708 #:cpu1709)
#:g1712)))
(let* ((#:g1715 1) (#:g1716 6) (#:cpu1714 cpu))
(let ((#:g1717
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1713 (dpb #:g1717 (byte #:g1715 #:g1716) (cpu-sr #:cpu1714))))
(funcall #'(setf cpu-sr) #:new1713 #:cpu1714)
#:g1717)))
(let* ((#:g1720 1) (#:g1721 7) (#:cpu1719 cpu))
(let ((#:g1722
(if (logbitp 7 result)
1
0)))
(let ((#:new1718 (dpb #:g1722 (byte #:g1720 #:g1721) (cpu-sr #:cpu1719))))
(funcall #'(setf cpu-sr) #:new1718 #:cpu1719)
#:g1722)))
(let* ((#:g1725 1) (#:g1726 1) (#:cpu1724 cpu))
(let ((#:g1727
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1723 (dpb #:g1727 (byte #:g1725 #:g1726) (cpu-sr #:cpu1724))))
(funcall #'(setf cpu-sr) #:new1723 #:cpu1724)
#:g1727))))
(let* ((#:cpu1729 cpu))
(let ((#:new1728 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1728 #:cpu1729)))))
(let* ((#:cpu1731 cpu)
(#:g1732 1)
(#:new1730 (+ (cpu-pc #:cpu1731) #:g1732)))
(funcall #'(setf cpu-pc) #:new1730 #:cpu1731))
(let* ((#:cpu1734 cpu)
(#:g1735 3)
(#:new1733 (+ (cpu-cc #:cpu1734) #:g1735)))
(funcall #'(setf cpu-cc) #:new1733 #:cpu1734))))
#'adc-65)))
(funcall #'(setf aref) #:new1696 #:*opcode-funs*1697 101)))
(let* ((#:*opcode-funs*1737 *opcode-funs*))
(let ((#:new1736
(labels ((adc-69 (cpu)
(let* ((#:cpu1742 cpu)
(#:g1743 1)
(#:new1741 (+ (cpu-pc #:cpu1742) #:g1743)))
(funcall #'(setf cpu-pc) #:new1741 #:cpu1742))
(flet ((getter ()
(get-byte (immediate cpu)))
(setter (x)
(let* ((#:cpu1747 cpu))
(let ((#:new1746 x))
(funcall #'(setf immediate) #:new1746 #:cpu1747)))))
(let ((result
(+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1750 1) (#:g1751 0) (#:cpu1749 cpu))
(let ((#:g1752
(if (> result 255)
1
0)))
(let ((#:new1748 (dpb #:g1752 (byte #:g1750 #:g1751) (cpu-sr #:cpu1749))))
(funcall #'(setf cpu-sr) #:new1748 #:cpu1749)
#:g1752)))
(let* ((#:g1755 1) (#:g1756 6) (#:cpu1754 cpu))
(let ((#:g1757
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1753 (dpb #:g1757 (byte #:g1755 #:g1756) (cpu-sr #:cpu1754))))
(funcall #'(setf cpu-sr) #:new1753 #:cpu1754)
#:g1757)))
(let* ((#:g1760 1) (#:g1761 7) (#:cpu1759 cpu))
(let ((#:g1762
(if (logbitp 7 result)
1
0)))
(let ((#:new1758 (dpb #:g1762 (byte #:g1760 #:g1761) (cpu-sr #:cpu1759))))
(funcall #'(setf cpu-sr) #:new1758 #:cpu1759)
#:g1762)))
(let* ((#:g1765 1) (#:g1766 1) (#:cpu1764 cpu))
(let ((#:g1767
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1763 (dpb #:g1767 (byte #:g1765 #:g1766) (cpu-sr #:cpu1764))))
(funcall #'(setf cpu-sr) #:new1763 #:cpu1764)
#:g1767))))
(let* ((#:cpu1769 cpu))
(let ((#:new1768 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1768 #:cpu1769)))))
(let* ((#:cpu1771 cpu)
(#:g1772 1)
(#:new1770 (+ (cpu-pc #:cpu1771) #:g1772)))
(funcall #'(setf cpu-pc) #:new1770 #:cpu1771))
(let* ((#:cpu1774 cpu)
(#:g1775 2)
(#:new1773 (+ (cpu-cc #:cpu1774) #:g1775)))
(funcall #'(setf cpu-cc) #:new1773 #:cpu1774))))
#'adc-69)))
(funcall #'(setf aref) #:new1736 #:*opcode-funs*1737 105)))
(let* ((#:*opcode-funs*1777 *opcode-funs*))
(let ((#:new1776
(labels ((adc-6d (cpu)
(let* ((#:cpu1782 cpu)
(#:g1783 1)
(#:new1781 (+ (cpu-pc #:cpu1782) #:g1783)))
(funcall #'(setf cpu-pc) #:new1781 #:cpu1782))
(flet ((getter ()
(get-byte (absolute cpu)))
(setter (x)
(let* ((#:cpu1787 cpu))
(let ((#:new1786 x))
(funcall #'(setf absolute) #:new1786 #:cpu1787)))))
(let ((result
(+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1790 1) (#:g1791 0) (#:cpu1789 cpu))
(let ((#:g1792
(if (> result 255)
1
0)))
(let ((#:new1788 (dpb #:g1792 (byte #:g1790 #:g1791) (cpu-sr #:cpu1789))))
(funcall #'(setf cpu-sr) #:new1788 #:cpu1789)
#:g1792)))
(let* ((#:g1795 1) (#:g1796 6) (#:cpu1794 cpu))
(let ((#:g1797
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1793 (dpb #:g1797 (byte #:g1795 #:g1796) (cpu-sr #:cpu1794))))
(funcall #'(setf cpu-sr) #:new1793 #:cpu1794)
#:g1797)))
(let* ((#:g1800 1) (#:g1801 7) (#:cpu1799 cpu))
(let ((#:g1802
(if (logbitp 7 result)
1
0)))
(let ((#:new1798 (dpb #:g1802 (byte #:g1800 #:g1801) (cpu-sr #:cpu1799))))
(funcall #'(setf cpu-sr) #:new1798 #:cpu1799)
#:g1802)))
(let* ((#:g1805 1) (#:g1806 1) (#:cpu1804 cpu))
(let ((#:g1807
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1803 (dpb #:g1807 (byte #:g1805 #:g1806) (cpu-sr #:cpu1804))))
(funcall #'(setf cpu-sr) #:new1803 #:cpu1804)
#:g1807))))
(let* ((#:cpu1809 cpu))
(let ((#:new1808 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1808 #:cpu1809)))))
(let* ((#:cpu1811 cpu)
(#:g1812 2)
(#:new1810 (+ (cpu-pc #:cpu1811) #:g1812)))
(funcall #'(setf cpu-pc) #:new1810 #:cpu1811))
(let* ((#:cpu1814 cpu)
(#:g1815 4)
(#:new1813 (+ (cpu-cc #:cpu1814) #:g1815)))
(funcall #'(setf cpu-cc) #:new1813 #:cpu1814))))
#'adc-6d)))
(funcall #'(setf aref) #:new1776 #:*opcode-funs*1777 109)))
(let* ((#:*opcode-funs*1817 *opcode-funs*))
(let ((#:new1816
(labels ((adc-71 (cpu)
(let* ((#:cpu1822 cpu)
(#:g1823 1)
(#:new1821 (+ (cpu-pc #:cpu1822) #:g1823)))
(funcall #'(setf cpu-pc) #:new1821 #:cpu1822))
(flet ((getter ()
(get-byte (indirect-y cpu)))
(setter (x)
(let* ((#:cpu1827 cpu))
(let ((#:new1826 x))
(funcall #'(setf indirect-y) #:new1826 #:cpu1827)))))
(let ((result
(+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1830 1) (#:g1831 0) (#:cpu1829 cpu))
(let ((#:g1832
(if (> result 255)
1
0)))
(let ((#:new1828 (dpb #:g1832 (byte #:g1830 #:g1831) (cpu-sr #:cpu1829))))
(funcall #'(setf cpu-sr) #:new1828 #:cpu1829)
#:g1832)))
(let* ((#:g1835 1) (#:g1836 6) (#:cpu1834 cpu))
(let ((#:g1837
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1833 (dpb #:g1837 (byte #:g1835 #:g1836) (cpu-sr #:cpu1834))))
(funcall #'(setf cpu-sr) #:new1833 #:cpu1834)
#:g1837))(let ((#:g1837
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1833 (dpb #:g1837 (byte #:g1835 #:g1836) (cpu-sr #:cpu1834))))
(funcall #'(setf cpu-sr) #:new1833 #:cpu1834)
#:g1837)))
(let* ((#:g1840 1) (#:g1841 7) (#:cpu1839 cpu))
(let ((#:g1842
(if (logbitp 7 result)
1
0)))
(let ((#:new1838 (dpb #:g1842 (byte #:g1840 #:g1841) (cpu-sr #:cpu1839))))
(funcall #'(setf cpu-sr) #:new1838 #:cpu1839)
#:g1842)))
(let* ((#:g1845 1) (#:g1846 1) (#:cpu1844 cpu))
(let ((#:g1847
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1843 (dpb #:g1847 (byte #:g1845 #:g1846) (cpu-sr #:cpu1844))))
(funcall #'(setf cpu-sr) #:new1843 #:cpu1844)
#:g1847))))
(let* ((#:cpu1849 cpu))
(let ((#:new1848 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1848 #:cpu1849)))))
(let* ((#:cpu1851 cpu)
(#:g1852 1)
(#:new1850 (+ (cpu-pc #:cpu1851) #:g1852)))
(funcall #'(setf cpu-pc) #:new1850 #:cpu1851))
(let* ((#:cpu1854 cpu)
(#:g1855 5)
(#:new1853 (+ (cpu-cc #:cpu1854) #:g1855)))
(funcall #'(setf cpu-cc) #:new1853 #:cpu1854))))
#'adc-71)))
(funcall #'(setf aref) #:new1816 #:*opcode-funs*1817 113)))
(let* ((#:*opcode-funs*1857 *opcode-funs*))
(let ((#:new1856
(labels ((adc-75 (cpu)
(let* ((#:cpu1862 cpu)
(#:g1863 1)
(#:new1861 (+ (cpu-pc #:cpu1862) #:g1863)))
(funcall #'(setf cpu-pc) #:new1861 #:cpu1862))
(flet ((getter ()
(get-byte (zero-page-x cpu)))
(setter (x)
(let* ((#:cpu1867 cpu))
(let ((#:new1866 x))
(funcall #'(setf zero-page-x) #:new1866 #:cpu1867)))))
(let ((result
(+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1870 1) (#:g1871 0) (#:cpu1869 cpu))
(let ((#:g1872
(if (> result 255)
1
0)))
(let ((#:new1868 (dpb #:g1872 (byte #:g1870 #:g1871) (cpu-sr #:cpu1869))))
(funcall #'(setf cpu-sr) #:new1868 #:cpu1869)
#:g1872)))
(let* ((#:g1875 1) (#:g1876 6) (#:cpu1874 cpu))
(let ((#:g1877
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1873 (dpb #:g1877 (byte #:g1875 #:g1876) (cpu-sr #:cpu1874))))
(funcall #'(setf cpu-sr) #:new1873 #:cpu1874)
#:g1877)))
(let* ((#:g1880 1) (#:g1881 7) (#:cpu1879 cpu))
(let ((#:g1882
(if (logbitp 7 result)
1
0)))
(let ((#:new1878 (dpb #:g1882 (byte #:g1880 #:g1881) (cpu-sr #:cpu1879))))
(funcall #'(setf cpu-sr) #:new1878 #:cpu1879)
#:g1882)))
(let* ((#:g1885 1) (#:g1886 1) (#:cpu1884 cpu))
(let ((#:g1887
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1883 (dpb #:g1887 (byte #:g1885 #:g1886) (cpu-sr #:cpu1884))))
(funcall #'(setf cpu-sr) #:new1883 #:cpu1884)
#:g1887))))
(let* ((#:cpu1889 cpu))
(let ((#:new1888 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1888 #:cpu1889)))))
(let* ((#:cpu1891 cpu)
(#:g1892 1)
(#:new1890 (+ (cpu-pc #:cpu1891) #:g1892)))
(funcall #'(setf cpu-pc) #:new1890 #:cpu1891))
(let* ((#:cpu1894 cpu)
(#:g1895 4)
(#:new1893 (+ (cpu-cc #:cpu1894) #:g1895)))
(funcall #'(setf cpu-cc) #:new1893 #:cpu1894))))
#'adc-75)))
(funcall #'(setf aref) #:new1856 #:*opcode-funs*1857 117)))
(let* ((#:*opcode-funs*1897 *opcode-funs*))
(let ((#:new1896
(labels ((adc-79 (cpu)
(let* ((#:cpu1902 cpu)
(#:g1903 1)
(#:new1901 (+ (cpu-pc #:cpu1902) #:g1903)))
(funcall #'(setf cpu-pc) #:new1901 #:cpu1902))
(flet ((getter ()
(get-byte (absolute-y cpu)))
(setter (x)
(let* ((#:cpu1907 cpu))
(let ((#:new1906 x))
(funcall #'(setf absolute-y) #:new1906 #:cpu1907)))))
(let ((result
(+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1910 1) (#:g1911 0) (#:cpu1909 cpu))
(let ((#:g1912
(if (> result 255)
1
0)))
(let ((#:new1908 (dpb #:g1912 (byte #:g1910 #:g1911) (cpu-sr #:cpu1909))))
(funcall #'(setf cpu-sr) #:new1908 #:cpu1909)
#:g1912)))
(let* ((#:g1915 1) (#:g1916 6) (#:cpu1914 cpu))
(let ((#:g1917
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1913 (dpb #:g1917 (byte #:g1915 #:g1916) (cpu-sr #:cpu1914))))
(funcall #'(setf cpu-sr) #:new1913 #:cpu1914)
#:g1917)))
(let* ((#:g1920 1) (#:g1921 7) (#:cpu1919 cpu))
(let ((#:g1922
(if (logbitp 7 result)
1
0)))
(let ((#:new1918 (dpb #:g1922 (byte #:g1920 #:g1921) (cpu-sr #:cpu1919))))
(funcall #'(setf cpu-sr) #:new1918 #:cpu1919)
#:g1922)))
(let* ((#:g1925 1) (#:g1926 1) (#:cpu1924 cpu))
(let ((#:g1927
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1923 (dpb #:g1927 (byte #:g1925 #:g1926) (cpu-sr #:cpu1924))))
(funcall #'(setf cpu-sr) #:new1923 #:cpu1924)
#:g1927))))
(let* ((#:cpu1929 cpu))
(let ((#:new1928 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1928 #:cpu1929)))))
(let* ((#:cpu1931 cpu)
(#:g1932 2)
(#:new1930 (+ (cpu-pc #:cpu1931) #:g1932)))
(funcall #'(setf cpu-pc) #:new1930 #:cpu1931))
(let* ((#:cpu1934 cpu)
(#:g1935 4)
(#:new1933 (+ (cpu-cc #:cpu1934) #:g1935)))
(funcall #'(setf cpu-cc) #:new1933 #:cpu1934))))
#'adc-79)))
(funcall #'(setf aref) #:new1896 #:*opcode-funs*1897 121)))
(let* ((#:*opcode-funs*1937 *opcode-funs*))
(let ((#:new1936
(labels ((adc-7d (cpu)
(let* ((#:cpu1942 cpu)
(#:g1943 1)
(#:new1941 (+ (cpu-pc #:cpu1942) #:g1943)))
(funcall #'(setf cpu-pc) #:new1941 #:cpu1942))
(flet ((getter ()
(get-byte (absolute-x cpu)))
(setter (x)
(let* ((#:cpu1947 cpu))
(let ((#:new1946 x))
(funcall #'(setf absolute-x) #:new1946 #:cpu1947))(let ((#:new1946 x))
(funcall #'(setf absolute-x) #:new1946 #:cpu1947)))))
(let ((result
(+ (cpu-ar cpu) (getter) (logand (cpu-sr cpu) 1))))
(progn
(let* ((#:g1950 1) (#:g1951 0) (#:cpu1949 cpu))
(let ((#:g1952
(if (> result 255)
1
0)))
(let ((#:new1948 (dpb #:g1952 (byte #:g1950 #:g1951) (cpu-sr #:cpu1949))))
(funcall #'(setf cpu-sr) #:new1948 #:cpu1949)
#:g1952)))
(let* ((#:g1955 1) (#:g1956 6) (#:cpu1954 cpu))
(let ((#:g1957
(if (overflow-p result (cpu-ar cpu) (getter))
1
0)))
(let ((#:new1953 (dpb #:g1957 (byte #:g1955 #:g1956) (cpu-sr #:cpu1954))))
(funcall #'(setf cpu-sr) #:new1953 #:cpu1954)
#:g1957)))
(let* ((#:g1960 1) (#:g1961 7) (#:cpu1959 cpu))
(let ((#:g1962
(if (logbitp 7 result)
1
0)))
(let ((#:new1958 (dpb #:g1962 (byte #:g1960 #:g1961) (cpu-sr #:cpu1959))))
(funcall #'(setf cpu-sr) #:new1958 #:cpu1959)
#:g1962)))
(let* ((#:g1965 1) (#:g1966 1) (#:cpu1964 cpu))
(let ((#:g1967
(if (zerop (wrap-byte result))
1
0)))
(let ((#:new1963 (dpb #:g1967 (byte #:g1965 #:g1966) (cpu-sr #:cpu1964))))
(funcall #'(setf cpu-sr) #:new1963 #:cpu1964)
#:g1967))))
(let* ((#:cpu1969 cpu))
(let ((#:new1968 (wrap-byte result)))
(funcall #'(setf cpu-ar) #:new1968 #:cpu1969)))))
(let* ((#:cpu1971 cpu)
(#:g1972 2)
(#:new1970 (+ (cpu-pc #:cpu1971) #:g1972)))
(funcall #'(setf cpu-pc) #:new1970 #:cpu1971))
(let* ((#:cpu1974 cpu)
(#:g1975 4)
(#:new1973 (+ (cpu-cc #:cpu1974) #:g1975)))
(funcall #'(setf cpu-cc) #:new1973 #:cpu1974))))
#'adc-7d)))
(funcall #'(setf aref) #:new1936 #:*opcode-funs*1937 125))))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment