Macroexpansion of defasm

gistfile1.txt

(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))))