/* THIS IS THE BASIC-TO-C++ GENERATED OUTPUT OF cpu.bas GENERATED BY QBC */

#define B_NO_ERROR_HANDLING 1

#include <qblib.hh>
#include <ctime>

namespace
{
    std::string B_CmdLine;
    std::size_t   B_DataPtr = 0;
static constexpr std::size_t DATA_COUNT = 893;
const char* const DATA_TABLE[DATA_COUNT] = {
"12", "13", "11", "13", "0", "0", "0", "0", "10", "0", "40", "50", "9", "0",
"40", "50", "10", "11", "10", "11", "1", "1", "1", "1", "20", "0", "8", "18",
"9", "0", "40", "50", "12", "17", "16", "16", "2", "2", "2", "2", "30", "0",
"40", "50", "9", "0", "40", "50", "10", "6", "10", "14", "3", "3", "4", "4",
"70", "0", "9", "50", "9", "0", "40", "50", "12", "13", "11", "13", "0", "0",
"0", "0", "11", "1", "41", "51", "61", "1", "41", "51", "10", "11", "10", "11",
"1", "1", "1", "1", "21", "1", "17", "18", "61", "1", "41", "51", "12", "17",
"16", "16", "2", "2", "2", "2", "31", "1", "41", "51", "9", "1", "41", "51",
"10", "6", "10", "14", "3", "3", "4", "4", "71", "1", "9", "51", "9", "1", "41",
"51", "10", "13", "11", "13", "0", "0", "0", "0", "12", "2", "42", "52", "9",
"2", "42", "52", "10", "11", "10", "11", "1", "1", "1", "1", "22", "2", "26",
"68", "62", "2", "42", "52", "12", "17", "16", "16", "2", "2", "2", "2", "32",
"2", "42", "52", "9", "2", "42", "52", "10", "6", "10", "14", "3", "3", "4",
"4", "72", "2", "9", "52", "9", "2", "42", "52", "12", "13", "11", "13", "0",
"0", "0", "0", "13", "3", "43", "53", "9", "3", "43", "53", "10", "11", "10",
"11", "1", "1", "1", "1", "23", "3", "35", "69", "63", "3", "43", "53", "12",
"17", "16", "16", "2", "2", "2", "2", "33", "3", "43", "53", "9", "3", "43",
"53", "10", "6", "10", "14", "3", "3", "4", "4", "73", "3", "9", "53", "9", "3",
"43", "53", "11", "13", "11", "13", "0", "0", "0", "0", "9", "4", "9", "54",
"64", "4", "44", "54", "10", "11", "10", "11", "1", "1", "1", "1", "24", "9",
"48", "14", "64", "4", "44", "54", "12", "16", "16", "15", "2", "2", "5", "5",
"34", "4", "44", "54", "64", "4", "44", "54", "10", "14", "10", "9", "7", "4",
"8", "9", "74", "4", "49", "58", "64", "4", "44", "54", "11", "13", "11", "13",
"0", "0", "0", "0", "65", "5", "45", "55", "65", "5", "45", "55", "10", "11",
"10", "11", "1", "1", "1", "1", "25", "5", "15", "55", "65", "5", "45", "55",
"12", "17", "17", "17", "2", "2", "5", "5", "19", "5", "45", "55", "65", "5",
"45", "55", "10", "6", "10", "6", "3", "3", "6", "6", "75", "5", "39", "59",
"65", "5", "45", "55", "11", "13", "11", "13", "0", "0", "0", "0", "66", "6",
"9", "56", "66", "6", "46", "56", "10", "11", "10", "11", "1", "1", "1", "1",
"36", "6", "29", "16", "66", "6", "46", "56", "12", "17", "16", "16", "2", "2",
"2", "2", "60", "6", "46", "56", "9", "6", "46", "56", "10", "6", "10", "14",
"3", "3", "4", "4", "28", "6", "9", "56", "9", "6", "46", "56", "11", "13",
"11", "13", "0", "0", "0", "0", "67", "7", "9", "57", "67", "7", "47", "57",
"10", "11", "10", "11", "1", "1", "1", "1", "27", "7", "9", "7", "67", "7",
"47", "57", "12", "17", "16", "16", "2", "2", "2", "2", "37", "7", "47", "57",
"9", "7", "47", "57", "10", "6", "10", "14", "3", "3", "4", "4", "38", "7", "9",
"57", "9", "7", "47", "57", "10", "254", "20", "2", "40", "4", "80", "6", "160",
"8", "60", "10", "14", "12", "26", "14", "12", "16", "24", "18", "48", "20",
"96", "22", "192", "24", "72", "26", "16", "28", "32", "30", "2", "4", "8",
"16", "32", "48", "64", "80", "101", "127", "190", "254", "381", "508", "1017",
"2023", "428", "380", "340", "320", "286", "254", "226", "214", "190", "160",
"142", "128", "106", "84", "72", "54", "1", "1", "280", "280", "0", "1", "2",
"3", "4", "5", "6", "7", "8", "-1", "2", "1", "257", "257", "3", "6", "-1", "2",
"1", "271", "271", "0", "2", "5", "-1", "2", "19", "305", "324", "3", "0", "2",
"5", "1", "4", "8", "-1", "3", "1", "309", "309", "0", "1", "2", "3", "4", "5",
"8", "-1", "4", "1", "329", "329", "0", "1", "2", "8", "-1", "5", "1", "0",
"270", "2", "5", "-1", "5", "1", "260", "270", "0", "-1", "5", "1", "330",
"340", "2", "0", "1", "8", "-1", "6", "1", "1", "256", "0", "-1", "7", "1",
"257", "259", "0", "-1", "8", "8", "8", "256", "0", "1", "-1", "8", "8", "328",
"336", "0", "1", "-1", "16", "1", "256", "256", "0", "1", "-1", "32", "1",
"257", "257", "0", "1", "-1", "64", "1", "280", "304", "1", "-1", "128", "1",
"1", "255", "0", "1", "-1", "128", "1", "321", "336", "0", "1", "-1", "256",
"2", "2", "64", "0", "-1", "512", "2", "66", "256", "0", "-1", "1024", "8", "9",
"257", "0", "-1", "1024", "8", "329", "337", "0", "1", "-1", "&H0800", "8", "1",
"337", "0", "1", "-1", "&H1000", "8", "3", "339", "0", "1", "-1", "&H1800", "8",
"2", "242", "0", "-1", "&H1800", "8", "322", "330", "0", "1", "-1", "&H2000",
"8", "4", "244", "0", "-1", "&H2000", "8", "324", "332", "0", "1", "-1",
"&H2800", "8", "5", "253", "0", "1", "-1", "&H2800", "8", "325", "333", "0",
"1", "-1", "&H3000", "8", "7", "255", "0", "1", "-1", "&H3000", "8", "327",
"335", "0", "1", "-1", "&H3800", "8", "6", "246", "0", "-1", "&H3800", "8",
"326", "334", "0", "1", "-1", "&H4000", "8", "8", "248", "0", "-1", "&H4000",
"8", "328", "336", "0", "1", "-1", "&H4800", "8", "261", "317", "0", "1", "-1",
"&H5000", "8", "263", "319", "0", "1", "-1", "&H5800", "8", "262", "318", "0",
"-1", "&H6000", "8", "264", "320", "0", "-1", "0", "3C4", "604", "100", "0",
"3C2", "E3E3", "0", "3C4", "300", "0", "3D4", "2C11", "0D06", "3E07", "EA10",
"AC11", "DF12", "E715", "0616", "0014", "E317", "2813", "0", "3C4", "F02", "0",
"0"
};

    template<typename T, unsigned numdims>
    class BAS_DYNARRAY
    {
    public:
        template<typename... U>
        BAS_DYNARRAY(U... dimensions)
        {
            Redim_Sizes(0,1, dimensions...);
        }

        void Redim_Sizes(unsigned,std::size_t total_size)
        {
            container.resize(total_size);
            //fprintf(stderr, "DYNARRAY at %p: Initial size=%u, data=%p\n", this,unsigned(total_size),&container[0]);
        }

        template<typename... U>
        void Redim_Sizes(unsigned which_index,std::size_t total_size, int min, std::size_t width, U... dimensions)
        {
            length[which_index] = width;
            begin[which_index]  = min;
            if(which_index == 1)
                factor[which_index-1] = length[which_index-1];
            else if(which_index > 0)
                factor[which_index-1] = factor[which_index-2] * length[which_index-1];
            Redim_Sizes(which_index+1, total_size*width, dimensions...);
        }

        void Redim(unsigned,std::size_t total_size)
        {
            container.resize(total_size);
            //fprintf(stderr, "DYNARRAY at %p: Redim to size=%u, data=%p\n", this,unsigned(total_size),&container[0]);
        }

        template<typename... U>
        void Redim(unsigned which_index,std::size_t total_size, int min, int max, U... dimensions)
        {
            std::size_t width = max-min+1;

            length[which_index] = width;
            begin[which_index]  = min;
            if(which_index == 1)
                factor[which_index-1] = length[which_index-1];
            else if(which_index > 0)
                factor[which_index-1] = factor[which_index-2] * length[which_index-1];
            Redim(which_index+1, total_size*width, dimensions...);
        }

        void Erase()
        {
            for(unsigned n=0; n<numdims; ++n) { length[n]=0; begin[n]=0; }
            for(unsigned n=0; n<numdims-1; ++n) { factor[n]=0; }
            container.clear();
        }

        int Lbound(int which_index=1) const __attribute__((regparm(2)))
        {
            std::size_t i = which_index - 1; // unsigned result
            if(unlikely(i >= numdims)) B_ERROR(9); // subscript out of range
            return begin[i];
        }
        int Ubound(int which_index=1) const __attribute__((regparm(2)))
        {
            std::size_t i = which_index - 1; // unsigned result
            if(unlikely(i >= numdims)) B_ERROR(9); // subscript out of range
            return begin[i] + length[i] - 1;
        }
    private:
        T& Index(std::size_t start,unsigned) __attribute__((regparm(6)))
        {
            //if(unlikely(start >= container.size())) B_ERROR(9);
            return container[start];
        }
        const T& Index(std::size_t start,unsigned) const __attribute__((regparm(6)))
        {
            //if(unlikely(start >= container.size())) B_ERROR(9);
            return container[start];
        }
    public:
        template<typename... U>
        inline T& Index(std::size_t start, unsigned which_index, int index, U... rest)
        {
            std::size_t offs = index - begin[which_index]; // unsigned result
            if(unlikely(offs >= length[which_index])) B_ERROR(9);
            if(which_index != 0) offs *= factor[which_index-1];
            return Index(start + offs, which_index+1, rest...);
        }

        template<typename... U>
        const inline T& Index(std::size_t start, unsigned which_index, int index, U... rest) const
        {
            std::size_t offs = index - begin[which_index]; // unsigned result
            if(unlikely(offs >= length[which_index])) B_ERROR(9);
            if(which_index != 0) offs *= factor[which_index-1];
            return Index(start + offs, which_index+1, rest...);
        }

    private:
        void RedimUpdate();
    public:
        // Should be private, but I can't figure out the syntax
        // to "friend" these to BAS_MAGICARRAY<T>::DynWrapper<numdims>
        std::size_t length[numdims];
        std::size_t factor[numdims > 1 ? numdims-1 : 1];
        int         begin[numdims];
        std::vector<T> container;
    };



    template<typename CharP>
    void SkipSpace(CharP& input)
    {
        for(;;)
            switch(*input)
            {
                case ' ':  case '\t':
                case '\v':
                case '\r': case '\n':
                    ++input;
                    break;
                default:
                    return;
            }
    }

    template<typename T, bool TrapErrors>
    void B_ReadGeneric(T& target, const char* input)
    {
        constexpr bool FloatType    = B_IsFloatType<T>::value;
        //constexpr bool UnsignedType = B_IsUnsignedType<T>::value;
        constexpr auto minvalue = B_MinValue<T>::value;
        constexpr auto maxvalue = B_MaxValue<T>::value;

        long double         longdouble_result;
        unsigned long long  longlong_result;
        bool negative           = false;
        bool definitely_integer = false;
        unsigned integer_base   = 10;

        SkipSpace(input);

        if(*input == '-') { negative = true; ++input; }
        if(*input == '+') ++input;

        if(*input == '&' && (input[1] == 'H' || input[1] == 'h'))
            { integer_base = 16; definitely_integer = true; input += 2; }
        else if(*input == '&' && (input[1] == 'O' || input[1] == 'o'))
            { integer_base =  8; definitely_integer = true; input += 2; }
        else if(*input == '&' && (input[1] == 'B' || input[1] == 'b'))
            { integer_base =  2; definitely_integer = true; input += 2; }
        else if(*input == '0' && (input[1] == 'X' || input[1] == 'x'))
            { integer_base = 16; definitely_integer = true; input += 2; }
        else if(*input == '0' && (input[1] == 'B' || input[1] == 'b'))
            { integer_base =  2; definitely_integer = true; input += 2; }

        if(unlikely(!*input)) { err: if(TrapErrors) B_ERROR(2); return; } // SYNTAX ERROR

        char*end = 0;
        longlong_result = std::strtoll(input, &end, integer_base);

        /* FIXME: Should support 'd' / 'D' here */
        if(!definitely_integer && (*end == '.' || *end == 'e' || *end == 'E'))
        {
            longdouble_result = std::strtold(input, &end);
            definitely_integer = false;
            if(*end == '!' || *end == '#') ++end;
        }
        else
        {
            longdouble_result = 0.l;
            switch(*end)
            {
                case '%':
                    ++end;
                    definitely_integer = true;
                    longlong_result = (signed short) longlong_result;
                    break;
                case '&':
                    ++end;
                    definitely_integer = true;
                    longlong_result = (signed long) longlong_result;
                    break;
                case '!':
                case '#':
                    if(definitely_integer) break;
                    ++end;
                    longdouble_result =  longlong_result;
                    definitely_integer = false;
                    break;
                default:
                    if(!definitely_integer)
                        longdouble_result = longlong_result;
                    if(definitely_integer && !negative && longlong_result <= 0xFFFFl)
                    {
                        signed short v = longlong_result;
                        if(v < 0) { negative=true; longlong_result = -(long long)v; } else longlong_result = v;
                    }
                    else if(definitely_integer && !negative && longlong_result <= 0xFFFFFFFFl)
                    {
                        signed long v = longlong_result;
                        if(v < 0) { negative=true; longlong_result = -(long long)v; } else longlong_result = v;
                    }
            }
        }

        SkipSpace(end);
        if(*end && TrapErrors) goto err;
        //fprintf(stderr, "VAL(%s) = %llu / %lf\n", input, longlong_result, longdouble_result);

        switch(negative*2 + definitely_integer)
        {
            case 0: // not negative, not integer
                target = longdouble_result;
                if(TrapErrors && unlikely(!FloatType && longdouble_result > maxvalue)) B_ERROR(6); // overflow
                break;
            case 1: // not negative, integer
                target = longlong_result;
                if(TrapErrors && unlikely(!FloatType && longlong_result > maxvalue)) B_ERROR(6); // overflow
                break;
            case 2: // negative, not integer
                target = -longdouble_result;
                if(TrapErrors && unlikely(!FloatType && longdouble_result > -minvalue)) B_ERROR(6); // overflow
                break;
            case 3: // negative, integer
                target = (-(long long)longlong_result);
                if(TrapErrors && unlikely(!FloatType && longlong_result > -minvalue)) B_ERROR(6); // overflow
                break;
        }
    }


    template<typename T>
    struct B_DoRead
    {
        B_DoRead(T& target, const char* input)
        {
            B_ReadGeneric<T, true>(target, input);
        }
    };

    template<>
    struct B_DoRead<std::string>
    {
        B_DoRead(std::string& target, const char* input)
        {
            target = input;
        }
    };

    static inline void B_StmtREAD() {}

    template<typename T, typename... Rest>
    void B_StmtREAD(T& target, Rest&&... rest)
    {
        if(unlikely( B_DataPtr >= DATA_COUNT)) { B_ERROR(4); } //OUT OF DATA
        B_DoRead<T>(target, DATA_TABLE[ B_DataPtr++ ]);

        B_StmtREAD( std::forward<Rest>(rest)... );
    }


}
#include <cmath>
namespace
{


}
#include <map>
#include <memory> // shared_ptr
#include <sstream>
namespace
{
    class InputStreamBase
    {
    public:
        InputStreamBase() {}
        virtual ~InputStreamBase() {}

        // LINE INPUT (console and file)
        virtual void ReadLine(std::string& target) = 0;

        // INPUT$  (console and file)
        virtual std::string Input_N(size_t n) = 0;

        virtual void BeginInput() = 0;
        virtual void InputTo(BAS_BYTE& target) = 0;
        virtual void InputTo(BAS_UBYTE& target) = 0;
        virtual void InputTo(BAS_INT& target) = 0;
        virtual void InputTo(BAS_UINT& target) = 0;
        virtual void InputTo(BAS_LNG& target) = 0;
        virtual void InputTo(BAS_ULONG& target) = 0;
        virtual void InputTo(BAS_OFFS& target) = 0;
        virtual void InputTo(BAS_UOFFS& target) = 0;
        virtual void InputTo(BAS_SGN& target) = 0;
        virtual void InputTo(BAS_DBL& target) = 0;
        virtual void InputTo(BAS_FLT& target) = 0;
        virtual void InputTo(std::string& target) = 0;
        virtual bool EndInputOkp() = 0; // end input, were all fields input?
        /* In console input:
             At call of EndInputOkp, false is returned
             if any of the InputTos caused error or if
             line was not completely emptied by InputTos
           In file input:
             InputTo may span multiple lines, half-read
             line does not matter. EndInputOkp returns false
             only if an InputTo was unsatisfied.
         */

        static inline const char* GetRedoMsg() { return "\n?Redo from start\n"; }

    private:
        InputStreamBase(const InputStreamBase&);
        void operator=(const InputStreamBase&);
    };

    class InputImplement: public InputStreamBase
    {
    protected:
        bool InputError;
        bool GotEOL;
    public:
        virtual void InputTo(BAS_INT& target)
        {
            long l = InputLong(); target = l;
            if(l < -32768 || l > 32767) GotOverflow();
        }
        virtual void InputTo(BAS_BYTE& target)
        {
            long l = InputLong(); target = l;
            if(l < -128 || l > 127) GotOverflow();
        }
        virtual void InputTo(BAS_UINT& target)
        {
            long l = InputLong(); target = l;
            if(l < 0 || l > 65535) GotOverflow();
        }
        virtual void InputTo(BAS_UBYTE& target)
        {
            long l = InputLong(); target = l;
            if(l < 0 || l > 255) GotOverflow();
        }
        virtual void InputTo(BAS_SGN& target)
        {
            target = InputLong();
        }
        virtual void InputTo(BAS_DBL& target)
        {
            target = InputLong();
        }
        virtual void InputTo(BAS_FLT& target)
        {
            target = InputLong();
        }
        virtual void InputTo(BAS_LNG& target)
        {
            long double l = InputLong(); target = l;
            if(l < -2147483648.0
            || l > 2147483647.0) GotOverflow();
        }
        virtual void InputTo(BAS_ULONG& target)
        {
            long double l = InputLong(); target = l;
            if(l < 0 || l > ~0u) GotOverflow();
        }
        virtual void InputTo(BAS_OFFS& target)
        {
            target = InputLong();
        }
        virtual void InputTo(BAS_UOFFS& target)
        {
            auto l = InputLong(); target = l;
            if(l < 0) GotOverflow();
        }
        virtual void InputTo(std::string& target)
        {
            // anything until comma or eol or eof
            // ignore spaces at beginning and end
            // if quote encountered while string empty, parse until quote or eol or eof.
            //    After quote, ignore spaces.
            target = "";
            bool quotemode = false;
            bool hadquote  = false;
            for(;;)
            {
                int ch = InputChar();
                if(ch == -1) break;
                if((target.empty() || hadquote) && (ch == ' ' || ch == '\t')) continue;

                /*fprintf(stderr, "gotc(%c)\n", ch);*/

                if(ch == '"' && target.empty()) { quotemode = true; continue; }
                if(ch == '"' && quotemode) { quotemode=false; hadquote=true; continue; }
                if(ch == ',' && !quotemode) break;
                if(hadquote) { InputError = true; break; }
                target += (char)ch;
            }
            std::size_t p=0;
            while(p < target.size() && (target[p]==' ' || target[p]=='\t')) ++p;
            target.erase(target.begin(), target.begin()+p); // LTRIM_S

            /*fprintf(stderr, "target(%s)err(%d)\n",
                target.c_str(), (int)InputError);*/
        }

    protected:
        virtual int InputChar() = 0;
        virtual void GotOverflow() = 0;

        long double InputLong()
        {
            // anything until comma or eol or eof
            // ignore spaces at beginning and end

            std::string target;
            for(;;)
            {
                int ch = InputChar();
                if(ch == -1) break;
                if(target.empty() && (ch == ' ' || ch == '\t')) continue;

                if(ch == ',') break;
                target += (char)ch;
            }

            char* endptr;
            const char* beginptr = target.c_str();
            long double res = strtold(beginptr, &endptr);
            /*fprintf(stderr, "res(%lf)begin(%s)end(%s)\n",
                (double)res,
                beginptr,
                endptr);*/

            if(endptr == beginptr) { InputError = true; return 0.0; }
            while(*endptr)
            {
                if(*endptr != ' ' && *endptr != '\t') { InputError = true; break; }
                ++endptr;
            }
            return res;
        }
        bool FinishInput()
        {
            while(!GotEOL)
            {
                int ch = InputChar();
                if(ch == -1) break;
                if(ch != ' ' || ch != '\t')
                {
                    //fprintf(stderr, "Finish: '%c'?\n", ch);
                    InputError = true; return false;
                }
            }
            return InputError;
        }
    };

    /* File input */
    class QbFIstream: public InputImplement
    {
    public:
        FILE* fp;
        std::vector<char> buffer;
    public:
        QbFIstream(int fd, unsigned reclen=0) : fp(fd < 0 ? nullptr : fdopen(fd, "r"))
        {
            if(fd < 0) return;
            if(!fp) std::perror("fdopen(\"r\"\051"); // \051 codes for ')'
            else if(reclen) { buffer.resize(reclen); std::setvbuf(fp, &buffer[0], _IOFBF, reclen); }
        }

        virtual void ReadLine(std::string& target)
        {
            target = "";
            for(;;)
            {
                int c = InputChar();
                if(c == '\r') continue;
                if(c == '\n' || c == -1) break;
                target += (char) c;
            }
        }

        virtual void BeginInput()
        {
            InputError = false;
            GotEOL     = false;
            // File:
            //   Do nothing. InputTo reads file.
        }

        virtual bool EndInputOkp()
        {
            // File:
            //   Return false if InputTo failed, true otherwise.
            if(InputError) return false;
            return !FinishInput();
        }

        virtual std::string Input_N(size_t n)
        {
            std::string buf(n, '\0');
            size_t res = fread(&buf[0], 1, n, fp);
            if(res == 0)
            {
                if(ferror(fp)) { clearerr(fp); B_ERROR_Errno(); }
            }
            buf.erase(buf.begin() + res, buf.end());
            return buf;
        }

        virtual int InputChar()
        {
         retry:;
            int res = fgetc(fp);
            if(res == '\r') goto retry;
            if(res == EOF || res == '\n') { GotEOL = true; return -1; }
            return res;
        }

        virtual void GotOverflow()
        {
            B_ERROR(6); // overflow
            InputError = true;
        }
    };

    struct PrintCRLFtag { };
    struct PrintSPCtag  { int count; };
    struct PrintTABtag  { int count; };
    struct PrintNextTABtag { };

    class PrintStreamBase
    {
    public:
        PrintStreamBase() {}
        virtual ~PrintStreamBase() {}

        PrintStreamBase& operator<< (BAS_INT v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_UINT v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_BYTE v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_UBYTE v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_ULONG v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_LNG v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_UOFFS v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_OFFS v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (long long v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (unsigned long long v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }
        PrintStreamBase& operator<< (BAS_SGN v)
        {
            std::ostringstream s; s << ' ' << v; WriteWithFitCheck( s.str() ); return *this;
        }
        PrintStreamBase& operator<< (BAS_DBL v)
        {
            std::ostringstream s; s << ' ' << v; WriteWithFitCheck( s.str() ); return *this;
        }
        PrintStreamBase& operator<< (BAS_FLT v)
        {
            std::ostringstream s; s << ' ' << v; WriteWithFitCheck( s.str() ); return *this;
        }
        PrintStreamBase& operator<< (const std::string& v)
        {
            WriteWithFitCheck(v); return *this;
        }
        /*PrintStreamBase& operator<< (long long int v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }*/
        PrintStreamBase& operator<< (const char* v)
        {
            WriteWithFitCheck(v); return *this;
        }
        PrintStreamBase& operator<< (char v)
        {
            WriteWithFitCheck(&v, 1); return *this;
        }
        /*PrintStreamBase& operator<< (std::size_t v)
        {
            WriteWithFitCheck( std::to_string(v) ); return *this;
        }*/

        inline PrintStreamBase& operator<< (PrintCRLFtag)    { DoCRLF();       return *this; }
        inline PrintStreamBase& operator<< (PrintNextTABtag) { DoNextTAB();    return *this; }
        inline PrintStreamBase& operator<< (PrintSPCtag t)   { DoSPC(t.count); return *this; }
        inline PrintStreamBase& operator<< (PrintTABtag t)   { DoTAB(t.count); return *this; }

        virtual void Write(const void* buf, size_t n) = 0;

        // DoCRLF is not the same as either '\r' nor '\n'.
        // Only on terminal, '\r' and '\n' both produce the same as DoCRLF().
        // In files, DoCRLF() produces '\r\n' whereas CHR$ produces individual bytes.
        virtual void DoCRLF() = 0;

        virtual unsigned GetXpos() const = 0;  // 0..n-1
        virtual unsigned GetXsize() const = 0; // n. 0 = infinite (files)

        // SPC() actually produces space characters. It does not only move the cursor.
        void DoSPC(int count)
        {
            if(count < 0) count = 0;

            unsigned xsize = GetXsize();
            if(xsize) count %= xsize;

            std::string spaces(count, ' ');
            Write(&spaces[0], spaces.size());
        }
        void DoTAB(int newpos)
        {
            --newpos;
            if(newpos < 0) newpos = 0;
            int xpos = GetXpos();
            unsigned xsize = GetXsize();
            if(xsize) newpos %= xsize;

            if(newpos < xpos) { xpos=newpos=0; DoCRLF(); }
            if(newpos > xpos) Write(std::string(newpos-xpos, ' '));
        }
        void DoNextTAB()
        {
            const unsigned ColumnWidth = 14;
            static const char SpaceBuf[ColumnWidth+1] = "              "; // 14 spaces
            int xpos = GetXpos();
            int columnpos   = xpos % ColumnWidth;
            int need_spaces = ColumnWidth - columnpos;
            if(CheckFit(need_spaces))
                Write(SpaceBuf, need_spaces);
        }
    private:
        bool CheckFit(int n_columns) // no const, it may print CRLF
        {
            int xsize = GetXsize(); if(!xsize) return true;
            int xpos = GetXpos();
            if(xpos+n_columns < xsize) return true;
            if(xpos > 0) DoCRLF();
            return false;
        }
        void WriteWithFitCheck(const void* buf, std::size_t n)
        {
            CheckFit(n);
            Write(buf, n);
        }
        void WriteWithFitCheck(const std::string& s)
        {
            WriteWithFitCheck(s.data(), s.size());
        }
        void Write(const std::string& s)
        {
            Write(s.data(), s.size());
        }

    private:
        PrintStreamBase(const PrintStreamBase&);
        void operator=(const PrintStreamBase&);
    };

    /* File writing */
    class QbFPstream: public PrintStreamBase
    {
    public:
        FILE* fp;
        int xpos;
        std::vector<char> buffer;
    public:
        QbFPstream(int fd, unsigned reclen=0) : fp(fd < 0 ? nullptr : fdopen(fd, "w")), xpos(0)
        {
            if(fd < 0) return;
            if(!fp) std::perror("fdopen(\"w\"\051"); // \051 codes for ')'
            else if(reclen) { buffer.resize(reclen); std::setvbuf(fp, &buffer[0], _IOFBF, reclen); }
        }

        virtual unsigned GetXpos() const
        {
            return xpos;
        }
        virtual unsigned GetXsize() const
        {
            return 65535;
        }
        virtual void DoCRLF()
        {
            fputc('\n', fp);
            fflush(fp);
        }
        virtual void Write(const void* buf, size_t n)
        {
            size_t res = fwrite(buf, 1, n, fp);
            if(!res) B_ERROR_Errno();
            fflush(fp);
        }
    };

    struct FileDescriptor
    {
        int fd; // system filedescriptor
        QbFPstream fpout;
        QbFIstream fpin;

        std::size_t record_width;

        struct Field
        {
            std::size_t offset;
            std::size_t width;
            std::string* target;
        };

        std::vector<Field> fields;

        bool readable;
        bool writable;

    public:
        FileDescriptor(int f, unsigned reclen, bool r,bool w)
            : fd(f),
              fpout(w ? f : -1, reclen),
              fpin(r ? f : -1, reclen),
              record_width(reclen),
              fields(), readable(r), writable(w)
        {
        }
    };
    std::map<int/*qbasic filenum*/, std::shared_ptr<FileDescriptor>> fdmap;

    extern PrintStreamBase& GET_PRINTER();

    InputStreamBase& GET_STREAM_INPUT(int filenumber)
    {
        auto i = fdmap.find(filenumber);
        if(i == fdmap.end()) B_ERROR(52); // bad file number
        if(!i->second->readable) B_ERROR(54); // bad file mode
        return i->second->fpin;
    }

    PrintStreamBase& GET_STREAM_OUTPUT(int filenumber)
    {
        auto i = fdmap.find(filenumber);
        if(i == fdmap.end()) B_ERROR(52); // bad file number
        if(!i->second->writable) B_ERROR(54); // bad file mode

        return i->second->fpout;
    }


}
#include <unistd.h> // isatty
namespace
{
    /* Console I/O */
    class QbConsoleStream: public PrintStreamBase, public InputImplement
    {
        std::string InputLineBuffer;
        unsigned InputLineBufferPos;
    public:
        QbConsoleStream() : PrintStreamBase(), InputImplement() { }

        virtual unsigned GetXpos() const
        {
            return B_FuncPOS();
        }
        virtual unsigned GetXsize() const
        {
            return B_FuncWIDTH();
        }
        virtual void DoCRLF()
        {
            GFX_OutS("\r", 1);
        }
        virtual void Write(const void* buf, size_t n)
        {
            GFX_OutS( (const char*) buf, n);
        }

        virtual void ReadLine(std::string& target)
        {
            target = "";
            std::size_t strpos = 0;
            int curspos = B_FuncPOS();
            bool insertmode = true;
            for(;;)
            {
                std::string inkey = B_FuncINKEY_S(true);
                if(inkey == "\n" || inkey == "\r") break;
                if(inkey[0] == '\0')
                    switch(inkey[1])
                    {
                        case 'K': // left
                            if(strpos > 0) { --strpos; --curspos; goto relocate; }
                            break;
                        case 'M': // right
                            if(strpos < target.size())
                                           { ++strpos; ++curspos; goto relocate; }
                            break;
                        case 'O': // end
                            curspos += target.size() - strpos;
                            strpos = target.size(); goto relocate;
                        case 'Q': // home
                            curspos -= strpos; strpos = 0; goto relocate;
                        default: continue;
                    }
                else if(inkey.size() == 1)
                    switch(inkey[0])
                    {
                        case 8: // backspace
                            if(strpos > 0)
                                { target.erase(--strpos, 1); --curspos;
                                  B_StmtLOCATE(-1, curspos);
                                  GFX_OutS(&target[strpos], target.size()-strpos);
                                  GFX_OutS(" ", 1);
                                  goto relocate;
                                }
                            continue;
                    }

                target.insert(strpos, inkey);

                GFX_OutS(&target[strpos], target.size()-strpos);

                if(insertmode)
                {
                    strpos += inkey.size();
                    curspos += inkey.size();
                }
                else
                    target.erase(strpos + inkey.size(), inkey.size());
            relocate:
                B_StmtLOCATE(-1, curspos);
            }

            if(strpos != target.size())
            {
                curspos += target.size() - strpos;
                strpos = target.size();
                B_StmtLOCATE(-1, curspos);
            }
            // note: does not go to next line.
        }

        virtual void BeginInput()
        {
            InputError = false;
            GotEOL     = false;
            // Console:
            //   Read line into buffer. InputTo queries buffer.
            ReadLine(InputLineBuffer); // note: keeps cursor on same line
            InputLineBufferPos=0;
        }

        virtual bool EndInputOkp()
        {
            // Console:
            //   Return false if InputTo failed.
            //   Return false if buffer is not empty.
            //   Return true otherwise.

            if(InputError) return false;
            return !FinishInput();
        }

        virtual std::string Input_N(size_t n)
        {
            // No echoing
            // FIXME: Don't take control chars.
            std::string res;
            for(; n > 0; --n) res += B_FuncINKEY_S(true);
            return res;
        }

        virtual int InputChar()
        {
            if(InputLineBufferPos < InputLineBuffer.size())
            {
                return InputLineBuffer[InputLineBufferPos++];
            }
            GotEOL = true;
            return -1;
        }

        virtual void GotOverflow()
        {
            InputError = true;
            *this << "Overflow\n";
        }
    } cons;

    InputStreamBase& GetStdin()  { static QbFIstream in(0); return in; }
    InputStreamBase& GET_STDIN() { static InputStreamBase& result = isatty(0) ? cons : GetStdin(); return result; }
    PrintStreamBase& GetStdout() { static QbFPstream out(1); return out; }
    PrintStreamBase& GET_STDOUT() { static PrintStreamBase& result = isatty(1) ? cons : GetStdout(); return result; }



    const std::string& B_FuncCOMMAND_S()
    {
        return B_CmdLine;
    }


}
#include <unistd.h>   // open,close
#include <fcntl.h>    // O_RDONLY
#include <sys/file.h> // flock
namespace
{
    void B_OPEN(const char* filename, BAS_INT filenumber,  unsigned mode_bitmask, BAS_LNG reclen=0)
    {
        if(fdmap.find(filenumber) != fdmap.end()) B_ERROR(55); // file already open
        if(reclen < 0) B_ERROR(63); // bad record length

        unsigned mode    = mode_bitmask >> 4;

        if(mode < 1 || mode > 4 || (mode_bitmask&3) == 0) B_ERROR(54); // bad file mode

        bool access_read  = mode_bitmask&1;
        bool access_write = mode_bitmask&2;
        bool lock_read    = mode_bitmask&4;
        bool lock_write   = mode_bitmask&8;

        // modes:   
        //   1=RANDOM
        //   2=INPUT and OUTPUT
        //   3=BINARY
        //   4=APPEND

        bool create   = access_write;
        bool truncate = access_write && !access_read && mode!=4;
        bool append   = access_write && mode==4;

        unsigned open_flags = access_read ? access_write ? O_RDWR : O_RDONLY : O_WRONLY;
        if(create)    open_flags |= O_CREAT;
        if(truncate)  open_flags |= O_TRUNC;
        if(append)    open_flags |= O_APPEND;

        if(reclen == 0) reclen = mode==2 ? 512 : 128;
        if(mode == 3) reclen = 1; // For BINARY files, ignore the record length

        int fd = open(filename, open_flags, 0644);
        if(fd < 0) B_ERROR_Errno();

        int lock_status = flock(fd, (lock_write || lock_read) ? LOCK_EX : LOCK_SH);
        if((lock_read || lock_write) && lock_status < 0)
        {
            close(fd);
            B_ERROR_Errno();
        }
        if(fd >= 0)
        {
            fdmap.emplace(filenumber, std::make_shared<FileDescriptor>(fd,reclen, access_read,access_write));
        }
    }

    void B_OPEN(const std::string& filename,BAS_INT filenumber,  unsigned mode_bitmask, BAS_LNG reclen=0)
    {
        B_OPEN(filename.c_str(), filenumber, mode_bitmask, reclen);
    }

    void B_OPEN(const std::string& filename,BAS_INT filenumber, const std::string& mode, unsigned bitmask, BAS_LNG reclen=0)
    {
        if(mode.size() == 1)
            switch(mode[0])
            {
                case 'O': B_OPEN(filename,filenumber, (2 << 4) + (bitmask|2), reclen); return;
                case 'I': B_OPEN(filename,filenumber, (2 << 4) + (bitmask|1), reclen); return;
                case 'R': B_OPEN(filename,filenumber, (1 << 4) + (bitmask|3), reclen); return;
                case 'B': B_OPEN(filename,filenumber, (3 << 4) + (bitmask|3), reclen); return;
                case 'A': B_OPEN(filename,filenumber, (4 << 4) + (bitmask|2), reclen); return;
            }
        B_ERROR(54); // bad file mode
    }


    long double B_FuncVAL(const std::string& s)
    {
        long double result;
        B_ReadGeneric<long double, false>(result, s.c_str());
        return result;
    }


    void B_StmtEND(int code = 0)    __attribute__((noreturn));
    void B_StmtEND(int code)
    {
        B_LibDone();
        std::exit(code);
    }


}
#include <sstream>
namespace
{
    std::string B_FuncHEX_S(BAS_LNG  i)  { std::ostringstream s;  s << std::uppercase << std::hex << (long)i; return s.str(); }
    std::string B_FuncHEX_S(BAS_ULONG i) { std::ostringstream s;  s << std::uppercase << std::hex << (unsigned long)i; return s.str(); }
    std::string B_FuncHEX_S(BAS_OFFS  i) { std::ostringstream s;  s << std::uppercase << std::hex << i; return s.str(); }
    std::string B_FuncHEX_S(BAS_UOFFS i) { std::ostringstream s;  s << std::uppercase << std::hex << i; return s.str(); }
    std::string B_FuncHEX_S(BAS_SGN i)   { return B_FuncHEX_S(BAS_LNG(std::round(i))); }
    std::string B_FuncHEX_S(BAS_DBL i)   { return B_FuncHEX_S(BAS_LNG(std::round(i))); }
    std::string B_FuncHEX_S(BAS_UINT i)  { return B_FuncHEX_S(BAS_ULONG(i)); }
    std::string B_FuncHEX_S(BAS_UBYTE i) { return B_FuncHEX_S(BAS_ULONG(i)); }
    std::string B_FuncHEX_S(BAS_INT i)   { return B_FuncHEX_S(BAS_LNG(i)); }
    std::string B_FuncHEX_S(BAS_BYTE i)  { return B_FuncHEX_S(BAS_LNG(i)); }


    std::string B_FuncSTRING_S(long n, const std::string& s)
    {
        if(unlikely(s.empty())) B_ERROR(5); // illegal function call
        return std::string(n, s[0]);
    }
    std::string B_FuncSTRING_S(long n, int i)
    {
        if(unlikely(i < 0 || i > 255)) B_ERROR(5); // illegal function call
        return std::string(n, (char) i);
    }


    void B_StmtCLOSE()
    {
        for(const auto& f: fdmap) close(f.second->fd);
        fdmap.clear();
    }
    void B_StmtCLOSE(BAS_INT filenumber)
    {
        auto i = fdmap.find(filenumber); if(i == fdmap.end()) B_ERROR(52); // bad file number
        close(i->second->fd);
        fdmap.erase(i);
    }


    BAS_INT B_FuncFREEFILE()
    {
        if(fdmap.empty()) return 1;
        return fdmap.rbegin()->first + 1;
    }


    typedef std::pair<struct FileDescriptor&,std::size_t> B_FIELD_Temp;

    B_FIELD_Temp B_FIELD_Init(BAS_INT filenumber)
    {
        auto i = fdmap.find(filenumber);
        if(i == fdmap.end()) B_ERROR(52); // bad file number
        auto& r = *i->second;
        //r.fields.clear();

        return { r, 0 };
    }

    B_FIELD_Temp B_FIELD(B_FIELD_Temp&& info, unsigned width, std::string& stringvar)
    {
        auto& r = info.first;
        std::size_t record_offset = info.second;
        if(record_offset + width > r.record_width) B_ERROR(50); // field overflow

        stringvar.assign(std::size_t(width), ' ');
        r.fields.emplace_back( FileDescriptor::Field{record_offset, width, &stringvar} );
        /*fprintf(stderr, "Field: assigned (%p) %u(%s)\n",
            &stringvar, (unsigned)stringvar.size(), stringvar.c_str());*/

        return { r, record_offset + width };
    }

    static inline void B_FIELD_Cont(const B_FIELD_Temp&) {}
    template<typename...T>
    static inline void B_FIELD_Cont(B_FIELD_Temp&& info,
                                    unsigned width, std::string& stringvar, T&&... rest)
    {
        B_FIELD_Cont(B_FIELD(std::move(info), width, stringvar), std::forward<T>(rest)...);
    }

    template<typename...T>
    static inline void B_StmtFIELD(BAS_INT filenumber, T&&... rest)
    {
        B_FIELD_Cont(B_FIELD_Init(filenumber), std::forward<T>(rest)...);
    }

 // File I/O
}
#include <assert.h>
namespace
{
    void B_StmtGET(BAS_INT filenumber, BAS_LNG recnumber=-1)
    {
        auto i = fdmap.find(filenumber);
        if(i == fdmap.end()) B_ERROR(52); // bad file number
        auto& r = *i->second;
        if(!r.readable) B_ERROR(54);      // bad file mode
        if(r.fields.empty()) B_ERROR(40); // variable required

        // TODO: If file is open in INPUT mode, "bad file mode"
        if(recnumber < -1 || recnumber == 0) B_ERROR(63); // bad record number

        if(recnumber > 0) std::fseek(r.fpin.fp, (recnumber-1) * r.record_width, SEEK_SET);

        std::vector<char> buffer(r.record_width);

        if(std::fread(&buffer[0], 1, buffer.size(), r.fpin.fp) == 0)
        {
            if(std::ferror(r.fpin.fp))
                B_ERROR_Errno();
            else
                B_ERROR(62); // input past end of file
        }

        for(const auto& field: r.fields)
        {
            /*fprintf(stderr, "Field offset %u, width %u, buffer is %u, target (%p) is %u(%s)\n",
                (unsigned)field.offset, (unsigned)field.width,
                (unsigned)buffer.size(), field.target, (unsigned)field.target->size(), field.target->c_str());*/

            assert(field.offset + field.width <= buffer.size());
            assert(field.width <= field.target->size());
            field.target->assign( &buffer[field.offset], field.width );
        }
    }

    void B_StmtGET(BAS_INT filenumber, BAS_LNG recnumber, void* target, std::size_t bytes)
    {
        auto i = fdmap.find(filenumber);
        if(i == fdmap.end()) B_ERROR(52); // bad file number
        auto& r = *i->second;
        if(!r.readable) B_ERROR(54);      // bad file mode

        if(!r.fields.empty()) B_ERROR(56); // field statement active

        // TODO: If file is open in INPUT or RANDOM mode, "bad file mode"

        if(recnumber < -1 || recnumber == 0) B_ERROR(63); // bad record number
        if(recnumber > 0) std::fseek(r.fpin.fp, (recnumber-1) * r.record_width, SEEK_SET);

        // TODO: If file is open in RANDOM mode and bytes doesn't match record_width, error

        if(std::fread(target, 1, bytes, r.fpin.fp) == 0)
        {
            if(std::ferror(r.fpin.fp))
                B_ERROR_Errno();
            else
                B_ERROR(62); // input past end of file
        }
    }

    static inline void B_StmtGET(BAS_INT filenumber, BAS_LNG recnumber, std::string& target)
        { B_StmtGET(filenumber,recnumber, target.empty() ? nullptr : (void*)&target[0], target.size()); }

    template<typename T>
    static inline void B_StmtGET(BAS_INT filenumber, BAS_LNG recnumber, T& target)
        { B_StmtGET(filenumber,recnumber,(void*)&target, sizeof(target)); }



    BAS_UBYTE B_FuncASC(const std::string& s)
    {
        if(unlikely(s.empty())) B_ERROR(5); // illegal function call
        return (unsigned char) s[0];
    }


    BAS_INT B_ASC_MID(const std::string& s, int offset)
    {
        std::size_t p = offset-1; // produces unsigned
        if(unlikely(p >= s.size())) B_ERROR(5); // illegal function call
        return (unsigned char) s [ p ];
    }


}
#include <cmath> /* For log10 and fabs */
namespace
{

/*
                     Characters that format a numeric expression
 #    Digit position.                    | -     Placed after digit, prints
 .    Decimal point position.            |       trailing sign for negative
 ,    Placed left of the decimal point,  |       numbers.
      prints a comma every third digit.  | $$    Prints leading $.
 +    Position of number sign.           | **    Fills leading spaces with *.
^^^^  Prints in exponential format.      | **$   Combines ** and $$.

                     Characters used to format a string expression
 &    Prints entire string.              | \ \   Prints first n characters,
 !    Prints only the first character    |       where n is the number of
      of the string.                     |       blanks between slashes + 2.

                     Characters used to print literal characters
 _    Prints the following formatting    |       Any character not in this
      character as a literal.            |       table is printed as a
                                         |       literal.
NOTES:
    $$ allocates two digit positions just like ## does
              except in scientific notation
    -  terminates the digit sequence (also counts as a character of sequence length)
       Note: If number is not negative, counts as a space
    .  also allocates one digit position
    ,  so does this. Note: Affects only once; position irrelvant.
    +  also allocates one digit position:
        Note: If comes ahead the sequence, indicates that
              sign is to be placed on left side of sequence
              If comes in middle of sequence, terminates the
              digit sequence (still allocates one slot).

    Example on using ^^^^:   (Note: D for doubles, E for others)

     |+#.##^^^^  for 123456 prints:
     |+1.23D+05
     |
     |+##.##^^^^  for 123456 prints:
     |+12.35D+04
     |
     |###.##^^^^^  for 123456 prints:
     | 12.35D+004
     |
     |###.##^^^^^+  for 123456 prints:
     |123.46D+003+
     |
     |$$#.##^^^^   for 123456 prints:
     | $1.23D+05
     |
     |**#.##^^^^   for 123456 prints:
     |*12.34D+04
     |
     |**#.##^^^^  for -123456 prints:
     |-12.34D+04
     |
     |**$.##^^^^   for 123456 prints:
     |*$1.23D+05
     |
     |**$.##^^^^  for -123456 prints:
     |-$1.23D+05
     |
     |#.##^^^^   for 123456 prints:
     |0.12D+06
     |
     |#.##^^^^  for -123456 prints:
     |-.12D+06

*/

class UsingFormatter
{
private:
    struct FormatItem
    {
        enum SignType
        {
            NormalSignLeft,    // number slot or -
            AlwaysSignLeft,    // + or -
            NegativeSignRight, // - or space (fill_char does not affect)
            AlwaysSignRight    // + or -
        };

        enum { Literal, String, Numeric } type;
        // For literals
        std::string literal;
        // For strings
        int         length; // -1=entire string
        // For numeric
        union
        {
            struct
            {
                /* Note: These fields are so constructed that 0 is a sensible
                 *       default for each field. */
                unsigned    num_leading_chars       : 8;
                unsigned    num_trailing_chars      : 8;
                unsigned    scientific              : 2; // 0, 2 or 3
                bool        fill_stars              : 1; // 0=spaces, 1=stars
                bool        decimal_point           : 1;
                bool        comma_every_third_digit : 1;
                bool        leading_dollar          : 1; // note: prints $ instead of last space
                SignType    sign_type               : 2;
                                            //       note: goes _after_ SignLeft
            };
            uint_least32_t numdata;
        };
    };
    std::vector<FormatItem> format;
    size_t pos;
public:
    explicit UsingFormatter(const std::string& f) : format(), pos(0) { CreateFormat(f); }
    ~UsingFormatter() {}

public:
    template<typename T, typename... Rest>
    inline PrintStreamBase& DoParam(PrintStreamBase& out, const T& value, Rest&&... rest)
    {
        return DoParam(Do1param(out, value), std::forward<Rest>(rest)...);
    }

    inline PrintStreamBase& DoParam(PrintStreamBase& out)
    {
        return out;
    }

private:
    /* Note: Do1param() can execute B_ERROR(13) (Type mismatch) */
    PrintStreamBase& Do1param(PrintStreamBase& out, BAS_SGN v)
    {
        return Do1param(out, (BAS_DBL)v, 'E');
    }
    PrintStreamBase& Do1param(PrintStreamBase& out, BAS_DBL v)
    {
        return Do1param(out, v, 'D');
    }
    PrintStreamBase& Do1param(PrintStreamBase& out, BAS_FLT v)
    {
        return Do1param(out, v, 'E');
    }
    PrintStreamBase& Do1param(PrintStreamBase& out, const std::string& v)
    {
        FlushLiterals(out, true);

        const FormatItem& format = GetFormat();
        if(format.type != FormatItem::String) B_ERROR(13); // type mismatch

        if(format.length == -1)
            out << v;
        else
        {
            size_t n_eat    = format.length;
            size_t n_spaces = 0;

            if(n_eat > v.size())
            {
                n_spaces = n_eat - v.size();
                n_eat    = v.size();
            }

            if(n_eat    > 0) out << v.substr(0, n_eat);
            if(n_spaces > 0) out << std::string(n_spaces, ' ');
        }

        FlushLiterals(out, false);

        return out;
    }

    PrintStreamBase& Do1param(PrintStreamBase& out, BAS_LNG v)
    {
        // 64-bit IEEE double has enough range to cover a 32-bit signed integer,
        // so to save effort and code, we handle it as a double.
        return Do1param(out, (BAS_FLT)v, 'E');
    }
    PrintStreamBase& Do1param(PrintStreamBase& out, BAS_ULONG v)
    {
        // FIXME: Is this safe?
        return Do1param(out, (BAS_FLT)v, 'E');
    }

    PrintStreamBase& Do1param(PrintStreamBase& out, BAS_OFFS v)
    {
        return Do1param(out, (BAS_FLT)v, 'E');
    }
    PrintStreamBase& Do1param(PrintStreamBase& out, BAS_UOFFS v)
    {
        // FIXME: Is this safe?
        return Do1param(out, (BAS_FLT)v, 'E');
    }

    inline PrintStreamBase& Do1param(PrintStreamBase& out, BAS_INT v)   { return Do1param(out, BAS_LNG(v)); }
    inline PrintStreamBase& Do1param(PrintStreamBase& out, BAS_BYTE v)  { return Do1param(out, BAS_LNG(v)); }
    inline PrintStreamBase& Do1param(PrintStreamBase& out, BAS_UBYTE v) { return Do1param(out, BAS_LNG(v)); }
    inline PrintStreamBase& Do1param(PrintStreamBase& out, BAS_UINT v)  { return Do1param(out, BAS_LNG(v)); }

    inline PrintStreamBase& Do1param(PrintStreamBase& out, const char* v) { return Do1param(out, std::string(v)); }
    inline PrintStreamBase& Do1param(PrintStreamBase& out, const char v)  { return Do1param(out, std::string(1,v)); }

    PrintStreamBase& Do1param(PrintStreamBase& out, const BAS_FLT v, char ExpChar)
    {
        FlushLiterals(out, true);

        const FormatItem& format = GetFormat();
        if(format.type != FormatItem::Numeric) B_ERROR(13); // type mismatch

        if(format.scientific)
        {
            //FIXME
            // Note: QB ignores comma in scientific mode.

            int leading_decimals = format.num_leading_chars;
            if(format.sign_type == FormatItem::AlwaysSignLeft
            || format.sign_type == FormatItem::NormalSignLeft)
            {
                --leading_decimals;
            }
            if(format.leading_dollar)
            {
                --leading_decimals;
            }

            // L = 10's exponent to divide v with,
            // so that result is 0.0 <= v < 1.0
            int L = (int) ((1 + 1e-8l) + std::log10( v==0.0l ? 1.0l : std::fabs(v) ));

            L -= leading_decimals;

            long double value = v / std::pow(10.0l, L);

            FormatItem tmpformat = format;
            tmpformat.scientific = false;
            if(format.sign_type == FormatItem::NegativeSignRight
            || format.sign_type == FormatItem::AlwaysSignRight)
            {
                tmpformat.sign_type = FormatItem::NormalSignLeft;
                value = std::fabs(value);
            }

            OutputNonscientific(out, value, tmpformat);

            char expo[512];
            sprintf(expo, "%c%+0*d", ExpChar, 1 + format.scientific, L);

            out << expo;

            if(format.sign_type == FormatItem::NegativeSignRight) out << (v < 0 ? '-' : ' ');
            if(format.sign_type == FormatItem::AlwaysSignRight) out << (v < 0 ? '-' : '+');
        }
        else
        {
            OutputNonscientific(out, v, format);
        }

        FlushLiterals(out, false);

        return out;
    }

    const FormatItem& GetFormat()
    {
        if(format.empty())
        {
            B_ERROR(5); // illegal function call
        }

        const FormatItem& result = format[pos];
        if(++pos == format.size()) pos = 0;
        return result;
    }

    void FlushLiterals(PrintStreamBase& out, bool allow_wrap)
    {
        if(format.empty())
        {
        Error:
            B_ERROR(5); // illegal function call
        }

        if(!allow_wrap && pos == 0) return;

        size_t origpos = pos;
        while(format[pos].type == FormatItem::Literal)
        {
            out << format[pos].literal;
            if(++pos == format.size()) pos = 0;
            if(pos == origpos) goto Error; // full loop without finding a parameter

            if(pos == 0 && !allow_wrap) break;
        }
    }

    void CreateFormat(const std::string& f)
    {
        if(false)
        {
        IllCall:
            format.clear(); // this will do IllCall at runtime
            return;
        }

        std::string literal;
        const char* const s = f.c_str();
        size_t spos = 0, slen = f.size();

        #define FlushLiteral() do { \
            if(!literal.empty()) \
            { \
                FormatItem tmp; \
                tmp.type    = FormatItem::Literal; \
                tmp.literal = literal; \
                format.push_back(tmp); \
                literal.clear(); \
            } \
        } while(0)

        while(spos < slen)
        {
            #define remain (slen-spos)
            #define c      (s[spos])

            if(c == '_' && remain >= 2)
            {
                literal += s[spos+1];
                spos += 2; continue;
            }
            if(c == '&')
            {
                FlushLiteral();
                FormatItem tmp;
                tmp.type   = FormatItem::String;
                tmp.length = -1;
                format.push_back(tmp);
                spos += 1; continue;
            }
            if(c == '!')
            {
                FlushLiteral();
                FormatItem tmp;
                tmp.type   = FormatItem::String;
                tmp.length = 1;
                format.push_back(tmp);
                spos += 1; continue;
            }
            if(c == '\\' && remain >= 2)
            {
                int strlen = 2;
                for(size_t p=spos+1; p<slen; ++p)
                {
                    if(s[p] == '\\') break;
                    if(s[p] != ' ') goto not_valid_backslash_thing;
                    ++strlen;
                }

                { FlushLiteral();
                FormatItem tmp;
                tmp.type   = FormatItem::String;
                tmp.length = strlen;
                format.push_back(tmp);
                spos += strlen; continue;
                }
            not_valid_backslash_thing:;
            }

            if(1) // numeric processing
            {
                size_t saved_spos = spos;

                #define RequireNextC(n) \
                    do { spos += n; if(spos >= slen) goto IllCall; \
                       } while(0)
                #define AcquireNextC(n) \
                    do { spos += n; if(spos >= slen) goto DoneNumFmt; \
                       } while(0)

                // be optimistic, start creating the numeral structure.
                FormatItem options_definitelynumeric;
                FormatItem options_maybenumeric;
                options_definitelynumeric.numdata = 0; // fill all numeric data by zero.
                options_maybenumeric.numdata = 0;

                if(c == '+') // heading +
                {
                    options_maybenumeric.sign_type         = FormatItem::AlwaysSignLeft;
                    options_maybenumeric.num_leading_chars += 1;
                    RequireNextC(1);
                }
                if(c == '$' && remain >= 2 && s[spos+1]=='$')
                {
                    options_definitelynumeric.leading_dollar    = true;
                    options_definitelynumeric.num_leading_chars += 2;
                    AcquireNextC(2);
                }
                else if(c == '*' && remain >= 2 && s[spos+1]=='*')
                {
                    int n = 2;
                    if(remain >= 3 && s[spos+2]=='$')
                    {
                        options_definitelynumeric.leading_dollar    = true;
                        n = 3;
                    }
                    options_definitelynumeric.fill_stars        = true;
                    options_definitelynumeric.num_leading_chars += n;
                    AcquireNextC(n);
                }
                for(;;)
                {
                    // FIXME: Only interpret ',' and '.' etc. if a decimal number is actually to be matched
                    if(c == ',' && !options_maybenumeric.decimal_point)
                    {
                        options_maybenumeric.comma_every_third_digit = true;
                        options_maybenumeric.num_leading_chars += 1;
                        AcquireNextC(1);
                    }
                    else if(c == '.' && !options_maybenumeric.decimal_point && !options_definitelynumeric.scientific)
                    {
                        options_maybenumeric.decimal_point = true;
                        AcquireNextC(1);
                    }
                    else if(c == '-' && options_maybenumeric.sign_type != FormatItem::AlwaysSignLeft)
                    {
                        options_maybenumeric.sign_type = FormatItem::NegativeSignRight;
                        AcquireNextC(1);
                        break; // end of the sequence.
                    }
                    else if(c == '+' && options_maybenumeric.sign_type != FormatItem::AlwaysSignLeft)
                    {
                        options_maybenumeric.sign_type = FormatItem::AlwaysSignRight;
                        AcquireNextC(1);
                        break; // end of the sequence.
                    }
                    else if(c == '#' && !options_definitelynumeric.scientific)
                    {
                        if(options_maybenumeric.decimal_point)
                            ++options_definitelynumeric.num_trailing_chars;
                        else
                            ++options_definitelynumeric.num_leading_chars;
                        AcquireNextC(1);
                    }
                    else if(remain >= 4 && c         == '^'
                                        && s[spos+1] == '^'
                                        && s[spos+2] == '^'
                                        && s[spos+3] == '^')
                    {
                        int n = 4;
                        if(remain >= 5 && s[spos+4] == '^') n=5;
                        options_definitelynumeric.scientific = n-2;
                        AcquireNextC(n);
                    }
                    else
                        break;
                }
            DoneNumFmt:;
                //fprintf(stderr, "DoneNumFmt(%s)\n", s+spos);
                if(options_definitelynumeric.numdata != 0) // if something was filled
                {
                    FormatItem tmp;
                    tmp.numdata = options_maybenumeric.numdata | options_definitelynumeric.numdata;

                    if(tmp.num_leading_chars == 0
                    && tmp.num_trailing_chars == 0)
                    {
                        // illegal pattern.
                        spos = saved_spos;
                    }
                    else
                    {
                        FlushLiteral();
                        tmp.type = FormatItem::Numeric;
                        format.push_back(tmp);
                        continue; // accept
                    }
                }
                #undef AcquireNextC
                #undef RequireNextC
            }

            // anything else:
            literal += c;
            spos += 1;

            #undef remain
            #undef c
        }
        FlushLiteral();
      #if 0
        fprintf(stderr, "%u format items\n",(unsigned)format.size());
        for(size_t n=0; n<format.size(); ++n)
        {
            FormatItem& fmt = format[n];
            switch(fmt.type)
            {
                case FormatItem::Literal:
                    fprintf(stderr, "[%d]: Literal \"%s\"\r\n",
                        (int)n, fmt.literal.c_str());
                    break;
                case FormatItem::String:
                    fprintf(stderr, "[%d]: String %d\r\n",
                        (int)n, fmt.length);
                    break;
                case FormatItem::Numeric:
                    fprintf(stderr, "[%d]: Numeric %d.%d sci=%d %s %s %s %s %d\r\n",
                        (int)n,
                        fmt.num_leading_chars,
                        fmt.num_trailing_chars,
                        fmt.scientific,
                        fmt.fill_stars ? "stars" : "no stars",
                        fmt.decimal_point ? "point" : "no point",
                        fmt.comma_every_third_digit ? "comma" : "no comma",
                        fmt.leading_dollar ? "dollar" : "no dollar",
                        (int)fmt.sign_type
                    );
                    break;
               default:
                   fprintf(stderr, "[%d]: eh?\r\n", (int)n);
            }
        }
        fflush(stderr);
      #endif
    }

    static void OutputNonscientific(
        PrintStreamBase& out,
        const BAS_DBL v,
        const UsingFormatter::FormatItem& format)
    {
        std::vector<char> Buffer;

        int bytes_required = snprintf(&Buffer[0], 0,
            "%.*f",
                (int) format.num_trailing_chars,
                std::fabs( v ));
        bytes_required += 8;

        Buffer.resize(bytes_required);

        int begin = 4;

        snprintf(&Buffer[begin], bytes_required - begin,
            "%.*f",
                (int) format.num_trailing_chars,
                std::fabs( v ));

        if(format.leading_dollar) Buffer[--begin] = '$';
        if(format.sign_type == FormatItem::NormalSignLeft && v < 0) Buffer[--begin] = '-';
        if(format.sign_type == FormatItem::AlwaysSignLeft) Buffer[--begin] = (v < 0 ? '-' : '+');

        std::string num_basis = &Buffer[begin];
        if(format.sign_type == FormatItem::NegativeSignRight) num_basis += (v < 0 ? '-' : ' ');
        if(format.sign_type == FormatItem::AlwaysSignRight) num_basis += (v < 0 ? '-' : '+');

        if(format.comma_every_third_digit)
        {
            std::string::size_type decimpoint = num_basis.find('.');
            if(decimpoint == num_basis.npos) decimpoint = num_basis.size();

            while(decimpoint > 3)
            {
                if(std::isdigit(num_basis[decimpoint-1])
                && std::isdigit(num_basis[decimpoint-2])
                && std::isdigit(num_basis[decimpoint-3])
                && std::isdigit(num_basis[decimpoint-4])
                  )
                {
                    num_basis.insert(decimpoint-3, 1, ',');
                    decimpoint -= 3;
                    continue;
                }
                break;
            }
        }

        std::string::size_type decimpoint = num_basis.find('.');
        if(decimpoint == num_basis.npos) decimpoint = num_basis.size();

        if(decimpoint == std::size_t(format.num_leading_chars+1)
        && num_basis[0]=='-'
        && num_basis[1]=='0'
        && num_basis[2]=='.')
        {
            --decimpoint;
            num_basis.erase(1,1);
        }

        if(decimpoint > format.num_leading_chars)
        {
            num_basis.insert(0, 1, '%'); // indicate overflow
        }
        else
        {
            num_basis.insert(0, format.num_leading_chars-decimpoint,
                                format.fill_stars ? '*' : ' ');
        }

        out << num_basis;
    }

private:
    UsingFormatter(const UsingFormatter&);
    void operator=(const UsingFormatter&);
};



}
#include <sys/time.h>
#include <cmath>      /* for std::floor */
namespace
{
    BAS_SGN B_FuncTIMER()
    {
        B_RerenderTextScreen();

        struct timeval tv;
        gettimeofday(&tv, 0);

        time_t midnight = tv.tv_sec;
        struct tm tm;
        localtime_r(&midnight, &tm);
        tm.tm_sec = 0;
        tm.tm_min = 0;
        tm.tm_hour = 0;
        midnight = std::mktime(&tm);

        float result = (tv.tv_sec - midnight) + tv.tv_usec * 1e-6f;
        //return result;

        /* Artificially add a 18.2 hz precision for QB compatibility */
        const float precision = 65536.0f / 0x1234DD;
        //const float precision = 0.5;

        return std::floor(result / precision) * precision;
    }


    std::string B_FuncCHR_S(long n) __attribute__((regparm(2)));
    std::string B_FuncCHR_S(long n)
    {
        if(unlikely(n < 0 || n > 255)) B_ERROR(5); // illegal function call"
        return std::string( std::size_t(1), char(n) );
    }


    void B_StmtDEFSEG(BAS_ULONG seg = ~BAS_ULONG(0))
    {
        B_DefSeg = seg;
    }


    template<typename T>
    static inline BAS_ULONG B_FuncVARSEG(const T& t)
        { return reinterpret_cast<std::size_t>(&t) >> 32; }


    template<typename T>
    static inline BAS_ULONG B_FuncVARPTR(const T& t)
        { return reinterpret_cast<std::size_t>(&t) & 0xFFFFFFFFul; }


    std::string B_FuncMID_S(const std::string& s, int pos, int count)
    {
        if(unlikely(pos <= 0 || count < 0)) B_ERROR(5);
        if((size_t)pos > s.size()) return {};
        return s.substr(pos-1, count);
    }


    void B_StmtLSET(std::string& result, const std::string& input)
    {
        std::size_t copy_length = std::min( result.size(), input.size() );
        std::size_t pad_length  = std::max( result.size(), input.size() );

        result.replace(0, copy_length, input, 0, copy_length);
        result.replace(copy_length, pad_length-copy_length, pad_length-copy_length, ' ');
    }


    std::string B_FuncLTRIM_S(const std::string& s)
    {
        std::size_t p = 0;
        while(p < s.size() && (s[p] == ' ' || s[p] == '\t')) ++p;
        return s.substr(p);
    }


}
#include <sstream>
namespace
{
    std::string B_FuncSTR_S(BAS_SGN d)   { std::ostringstream s; s << ' ' << d; return s.str(); }
    std::string B_FuncSTR_S(BAS_DBL d)   { std::ostringstream s; s << ' ' << d; return s.str(); }
    std::string B_FuncSTR_S(BAS_FLT d)   { std::ostringstream s; s << ' ' << d; return s.str(); }
    std::string B_FuncSTR_S(BAS_LNG  i)  { return " " + std::to_string(i); }
    std::string B_FuncSTR_S(BAS_ULONG i) { return " " + std::to_string(i); }
    std::string B_FuncSTR_S(BAS_OFFS  i) { return " " + std::to_string(i); }
    std::string B_FuncSTR_S(BAS_UOFFS i) { return " " + std::to_string(i); }
    std::string B_FuncSTR_S(BAS_BYTE i)  { return B_FuncSTR_S(BAS_LNG(i)); }
    std::string B_FuncSTR_S(BAS_INT  i)  { return B_FuncSTR_S(BAS_LNG(i)); }
    std::string B_FuncSTR_S(BAS_UBYTE i) { return B_FuncSTR_S(BAS_ULONG(i)); }
    std::string B_FuncSTR_S(BAS_UINT  i) { return B_FuncSTR_S(BAS_ULONG(i)); }

}
struct APUTYPE_ut {
  BAS_INT FRAMEDELAY_i;
  BAS_UBYTE CHANNELSENABLED_Y;
  BAS_UBYTE FRAME_Y;
  BAS_UBYTE IRQDISABLE_Y;
  BAS_UBYTE LINEARCOUNTERINIT_Y;
  BAS_UBYTE LINEARCOUNTER_Y;
  BAS_UBYTE NOISEFREQ_Y;
  BAS_UBYTE NOISETYPE_Y;
  BAS_INT NOISELFSR_i;
  BAS_INT ADDRESS_i;
  BAS_INT ADDRESSINIT_i;
  BAS_INT PCMLENGTH_i;
  BAS_UBYTE LOOPENABLED_Y;
  BAS_UBYTE IRQENABLE_Y;
  BAS_UBYTE PCMBYTE_Y;
};
struct APUCHANNELTYPE_ut {
  BAS_UBYTE ENVDECAYRATE_Y;
  BAS_UBYTE ENVDECAYDISABLE_Y;
  BAS_UBYTE ENVDECAYLOOPENABLE_Y;
  BAS_UBYTE ENVELOPE_Y;
  BAS_UBYTE ENVDELAY_Y;
  BAS_UBYTE LENGTHCOUNTERDISABLE_Y;
  BAS_UBYTE LENGTHCOUNTERINIT_Y;
  BAS_UBYTE LENGTHCOUNTER_Y;
  BAS_UBYTE DUTYCYCLE_Y;
  BAS_UBYTE SWEEPSHIFT_Y;
  BAS_UBYTE SWEEPDECREASE_Y;
  BAS_UBYTE SWEEPRATE_Y;
  BAS_UBYTE SWEEPENABLE_Y;
  BAS_UBYTE SWEEPDELAY_Y;
  BAS_INT WAVELENGTH_i;
  BAS_INT WAVECOUNTER_i;
  BAS_UBYTE PHASE_Y;
  BAS_UBYTE LEVEL_Y;
};
struct PPUTYPE_ut {
  BAS_UBYTE INC_Y;
  BAS_INT SPADDR_i;
  BAS_INT BGADDR_i;
  BAS_UBYTE SPSIZE_Y;
  BAS_UBYTE NMIENABLED_Y;
  BAS_UBYTE GRAYSCALE_Y;
  BAS_UBYTE SHOWBG8_Y;
  BAS_UBYTE SHOWSP8_Y;
  BAS_UBYTE SHOWBG_Y;
  BAS_UBYTE SHOWSP_Y;
  BAS_BYTE SHOW_y;
  BAS_LNG EMPHASISPHASES_l;
  BAS_UBYTE SPOVERFLOW_Y;
  BAS_UBYTE SP0HIT_Y;
  BAS_BYTE INVBLANK_y;
  BAS_UBYTE XCOARSE_Y;
  BAS_UBYTE YCOARSE_Y;
  BAS_INT YCOARSE32_i;
  BAS_INT BASENTA_i;
  BAS_UBYTE FINEY_Y;
  BAS_UBYTE OFFSETTOGGLE_Y;
  BAS_UBYTE XCOARSES_Y;
  BAS_UBYTE YCOARSES_Y;
  BAS_INT BASENTAS_i;
  BAS_UBYTE FINEYS_Y;
  BAS_UBYTE FINEXS_Y;
  BAS_INT FINEXSDIV_i;
  BAS_INT ADDRESSLINE_i;
  BAS_INT READBUFFER_i;
  BAS_UBYTE TILEPAT1_Y;
  BAS_UBYTE TILEPAT2_Y;
  BAS_UBYTE TILEATTR_Y;
  BAS_INT TILENUMBER_i;
  BAS_INT SHIFTPAT1_i;
  BAS_INT SHIFTPAT2_i;
  BAS_INT SHIFTATTR1_i;
  BAS_INT SHIFTATTR2_i;
  BAS_ULONG PIXELQUEUE_U;
  BAS_UBYTE OAMPOSLO_Y;
  BAS_UBYTE OAMPOSHI_Y;
  BAS_UBYTE OAM2POS_Y;
  BAS_UBYTE OAMPHASE_Y;
  BAS_UBYTE OAM3LIMIT_Y;
  BAS_INT ROW_i;
  BAS_INT COLUMN_i;
  BAS_ULONG CYCLECOUNT_U;
  BAS_INT ROWCLASS_i;
  BAS_ULONG FRAMECOUNT_U;
  BAS_LNG CURRENTSIGNALMODE_l;
};
struct CPUTYPE_ut {
  BAS_UBYTE A_Y;
  BAS_UBYTE X_Y;
  BAS_UBYTE Y_Y;
  BAS_UBYTE S_Y;
  BAS_INT PC_i;
  BAS_INT C_i;
  BAS_UBYTE I_Y;
  BAS_BYTE D_y;
  BAS_UBYTE V_Y;
  BAS_INT NZ_i;
  BAS_INT NMI_i;
  BAS_INT IRQ_i;
  BAS_INT NEXTOPCODE_i;
  BAS_UBYTE CYCLECOUNTER_Y;
  BAS_UBYTE DMCDELAY_Y;
};
/* These are global */
#line 380 "cpu.bas"
APUTYPE_ut APU_u { };
#line 336 "cpu.bas"
PPUTYPE_ut PPU_u { };
#line 315 "cpu.bas"
CPUTYPE_ut CPU_u { };
#line 380 "cpu.bas"
APUCHANNELTYPE_ut APUCHANNELS_u_a[5] = { };
#line 384 "cpu.bas"
BAS_SGN TURBOFACTOR_z { };
#line 342 "cpu.bas"
BAS_SGN FRAMETIMINGS_z_a[16] = { };
#line 463 "cpu.bas"
std::string BS_s { };
#line 120 "cpu.bas"
std::string OPCODENAMES_s { };
#line 332 "cpu.bas"
BAS_INT CHRSIZEPAGES_i { };
#line 325 "cpu.bas"
BAS_INT MAPPERNUM_i { };
#line 324 "cpu.bas"
BAS_INT PRGSIZEPAGES_i { };
#line 316 "cpu.bas"
BAS_INT ADDR_i { };
#line 389 "cpu.bas"
BAS_INT COLUMNCATEGORIES_i_a[3069] = { };
#line 379 "cpu.bas"
BAS_INT APUPERIODSDMC_i_a[16] = { };
#line 379 "cpu.bas"
BAS_INT APULENGTHS_i_a[32] = { };
#line 379 "cpu.bas"
BAS_INT APUNOISEPERIODS_i_a[16] = { };
#line 349 "cpu.bas"
BAS_INT SIGNALHI_i_a[64] = { };
#line 349 "cpu.bas"
BAS_INT SIGNALLO_i_a[64] = { };
#line 348 "cpu.bas"
BAS_INT SCALEDSINE_i_a[40] = { };
#line 337 "cpu.bas"
BAS_INT NTA_i_a[4] = { };
#line 463 "cpu.bas"
BAS_LNG SWAPPRGBASIS_l { };
#line 463 "cpu.bas"
BAS_LNG SWAPFILEHANDLE_l { };
#line 463 "cpu.bas"
BAS_LNG SWAPCHRBASIS_l { };
#line 380 "cpu.bas"
BAS_LNG SAMPLERATE_l { };
#line 332 "cpu.bas"
BAS_LNG CHRBANKS_l_a[8] = { };
#line 324 "cpu.bas"
BAS_LNG PRGBANKS_l_a[8] = { };
#line 348 "cpu.bas"
BAS_BYTE SIGNALHISTORY_y_a[24] = { };
#line 319 "cpu.bas"
BAS_BYTE JOYPOS_y_a[5] = { };
#line 120 "cpu.bas"
BAS_BYTE CPUOPS_y_a[256] = { };
#line 120 "cpu.bas"
BAS_BYTE CPUMODES_y_a[256] = { };
#line 316 "cpu.bas"
BAS_UBYTE PPUIOBYTE_Y { };
#line 316 "cpu.bas"
BAS_UBYTE IOBYTE_Y { };
#line 509 "cpu.bas"
BAS_UBYTE TRANSLATEREDBAYER_Y_a[448][4] = { };
#line 511 "cpu.bas"
BAS_UBYTE TRANSLATEBLUEBAYER_Y_a[448][4] = { };
#line 496 "cpu.bas"
BAS_UBYTE MODE13PIXELS_Y_a[641] = { };
#line 471 "cpu.bas"
BAS_UBYTE TRANSLATECOLOR_Y_a[448] = { };
#line 341 "cpu.bas"
BAS_UBYTE OAM3X_Y_a[8] = { };
#line 340 "cpu.bas"
BAS_UBYTE OAM3TILE2_Y_a[8] = { };
#line 323 "cpu.bas"
BAS_DYNARRAY<BAS_UBYTE, 1> PRGROM_Y_a(0,1);
#line 339 "cpu.bas"
BAS_UBYTE OAM2_Y_a[32] = { };
#line 325 "cpu.bas"
BAS_UBYTE MAPREG_Y_a[71] = { };
#line 510 "cpu.bas"
BAS_UBYTE TRANSLATEGREENBAYER_Y_a[448][4] = { };
#line 337 "cpu.bas"
BAS_UBYTE NRAM_Y_a[8192] = { };
#line 341 "cpu.bas"
BAS_UBYTE OAM3ATTR_Y_a[8] = { };
#line 319 "cpu.bas"
BAS_UBYTE JOYNEXT_Y_a[5] = { };
#line 340 "cpu.bas"
BAS_UBYTE OAM3TILE1_Y_a[8] = { };
#line 319 "cpu.bas"
BAS_UBYTE JOYCUR_Y_a[5] = { };
#line 327 "cpu.bas"
BAS_UBYTE WRAM_Y_a[8192] = { };
#line 331 "cpu.bas"
BAS_DYNARRAY<BAS_UBYTE, 1> CHRROM_Y_a(0,1);
#line 338 "cpu.bas"
BAS_UBYTE PRAM_Y_a[32] = { };
#line 315 "cpu.bas"
BAS_UBYTE RAM_Y_a[2048] = { };
#line 338 "cpu.bas"
BAS_UBYTE OAM_Y_a[256] = { };
/* These are local to this module */
template<bool insub>
static void B_StmtCLEAR(int=-1, int=-1, int=-1);
#line 0 ""
void PPUSPRITEEVALUATION_f();
#line 0 ""
void PPUCOPYVERT_f();
#line 0 ""
void PPUINCRVADDRVERT_f();
#line 109 "cpu.bas"
void JOYREAD_f(BAS_UBYTE INDEX_Y);
#line 106 "cpu.bas"
std::string HEXS_f(BAS_ULONG VALUE_U, BAS_INT WID_i);
#line 104 "cpu.bas"
void APUREAD_f();
#line 0 ""
void PPUCOPYVADDR_f();
#line 0 ""
void PPUINCRVADDR2007_f();
#line 0 ""
BAS_SGN APUMIXFUN_f(BAS_SGN M_z, BAS_SGN N_z, BAS_SGN D_z);
#line 100 "cpu.bas"
void CARTTICK_f();
#line 89 "cpu.bas"
void CARTLOAD_f(const std::string &F_s);
#line 93 "cpu.bas"
void DUMMYRB_f();
#line 107 "cpu.bas"
BAS_INT INCADDR_f(BAS_INT HOW_i);
#line 0 ""
void PPUINCROAMPOS_f();
#line 0 ""
void PPUTICKDOIO_f();
#line 98 "cpu.bas"
void MEMACCESS_f(BAS_INT W_i);
#line 0 ""
void APUFRAMETICK_f();
#line 102 "cpu.bas"
void PPUTICK_f();
#line 91 "cpu.bas"
void WB_f(BAS_UBYTE T_Y);
#line 0 ""
BAS_INT PPUGETVADDR_f();
#line 105 "cpu.bas"
void APUWRITE_f();
#line 0 ""
void PPUSHIFT_f();
#line 92 "cpu.bas"
BAS_UBYTE RB_f();
#line 0 ""
void PPUCOPYHORIZ_f();
#line 0 ""
void PPUINCRVADDRHORIZ_f();
#line 0 ""
void PPUINCROAMPOSHI_f();
#line 108 "cpu.bas"
BAS_INT FLAGS_f();
#line 0 ""
void PPUSETROWCLASS_f();
#line 101 "cpu.bas"
void CPUTICK_f(BAS_INT W_i);
#line 110 "cpu.bas"
void JOYSTROBE_f(BAS_UBYTE HOW_Y);
#line 103 "cpu.bas"
void APUTICK_f(BAS_INT W_i);
#line 97 "cpu.bas"
void SETFLAGS_f(BAS_UBYTE PVALUE_Y);
#line 99 "cpu.bas"
void PPUACCESS_f(BAS_INT W_i);
#line 115 "cpu.bas"
void PPURENDER_f(BAS_LNG MODE_l);
#line 94 "cpu.bas"
BAS_INT WBR_f(BAS_UBYTE T_Y);
#line 0 ""
BAS_INT APUTICKSQUARE_f(BAS_UBYTE C_Y, BAS_INT CYCLESACCUMULATED_i);
#line 95 "cpu.bas"
void RBMAKEADDR_f(BAS_UBYTE S_Y);
#line 0 ""
BAS_INT PPUGETVADDR12BIT_f();
#line 111 "cpu.bas"
void CARTSETPRG_f(BAS_UBYTE SIZE_Y, BAS_UBYTE BASEADDR_Y, BAS_INT INDEX_i);
#line 113 "cpu.bas"
void CARTACCESS_f(BAS_INT W_i);
#line 0 ""
BAS_INT APUTICKNOISE_f(BAS_INT CYCLESACCUMULATED_i);
#line 112 "cpu.bas"
void CARTSETCHR_f(BAS_UBYTE SIZE_Y, BAS_UBYTE BASEADDR_Y, BAS_INT INDEX_i);
#line 118 "cpu.bas"
BAS_INT YUVTORGBPALETTED_f(BAS_INT YIN_i, BAS_INT IIN_i, BAS_INT QIN_i, BAS_UBYTE BAYER_Y);
#line 0 ""
void PPUINCROAM2POS_f();
#line 114 "cpu.bas"
void CARTSETMIRRORING_f(BAS_INT MODE_i);
#line 116 "cpu.bas"
void TELEVISIONDECODE_f(BAS_BYTE LEVEL_y);
#line 96 "cpu.bas"
void DISASSEMBLYTRACE_f(BAS_INT WHERE_i, BAS_INT OP_i);
#line 117 "cpu.bas"
BAS_LNG YUVTORGB_f(BAS_INT YIN_i, BAS_INT IIN_i, BAS_INT QIN_i);
#line 0 ""
BAS_INT APUTICKTRIANGLE_f(BAS_INT CYCLESACCUMULATED_i);
#line 0 ""
BAS_INT APUTICKDPCM_f(BAS_INT CYCLESACCUMULATED_i, BAS_INT W_i);
#line 0 ""
void PPUINCROAMPOSLO_f();
#line 0 ""
BAS_INT PPUGETOAMPOS_f();
#line 90 "cpu.bas"
void CPUEXECUTE_f(BAS_UBYTE MODE_Y, BAS_INT OP_i);
#line 0 ""
BAS_INT PPUTESTVADDRIS3FXX_f();
namespace {
/* These are local to main() */
#line 474 "cpu.bas"
BAS_SGN P_z { };
#line 169 "cpu.bas"
std::string S_s { };
#line 169 "cpu.bas"
BAS_INT S_i { };
#line 169 "cpu.bas"
BAS_INT R_i { };
#line 168 "cpu.bas"
BAS_INT Q_i { };
#line 168 "cpu.bas"
BAS_INT N_i { };
#line 168 "cpu.bas"
BAS_INT M_i { };
// Automatically added temporaries:
BAS_INT fstp0_i { };
BAS_INT fend0_i { };
}
int main(int argc, char**argv)
{
for(int a=1; a<argc; ++a) { if(a>1) B_CmdLine += ' '; B_CmdLine += argv[a]; }
B_LibInit();
B_ERR_FRAME_MAIN_BEGIN();
#line 131 "cpu.bas"
OPCODENAMES_s = "ORAANDEORADCSTALDACMPSBCASLNOPBRKJSRRTIRTSANETAXSBXROLANCBCSPHPPLPPHAPLADEYT"
"AYLSRINXCLDDEXBPLBMIBVCBVSBCCRORINYBEQSEDTSXASLROLLSRRORSTXLDXDECINCTXATXSSL"
"ORLASRERRASAXLAXDCPISBSHSLASBNEBITJMPJMISTYLDYCPYCPXASRARRCLCSECCLISEITYACLV";
#line 169 "cpu.bas"
for(M_i = BAS_BYTE(0);M_i < BAS_INT(32);M_i += BAS_BYTE(1)) {
#line 169 "cpu.bas"
for(N_i = BAS_BYTE(0);N_i < BAS_INT(8);N_i += BAS_BYTE(1)) {
#line 169 "cpu.bas"
B_StmtREAD(CPUMODES_y_a[((M_i * BAS_UBYTE(8u)) + N_i)]);
}
#line 169 "cpu.bas"
for(N_i = BAS_BYTE(0);N_i < BAS_INT(8);N_i += BAS_BYTE(1)) {
#line 169 "cpu.bas"
B_StmtREAD(CPUOPS_y_a[((M_i * BAS_UBYTE(8u)) + N_i)]);
}
}
#line 350 "cpu.bas"
for(N_i = BAS_BYTE(0);N_i < BAS_INT(40);N_i += BAS_BYTE(1)) {
#line 350 "cpu.bas"
SCALEDSINE_i_a[N_i] = (
#line 350 "cpu.bas"
std::cos((((N_i + -1.8999999761581420898f) * 0.78539816339744830963) * 0.66666666666666666668)) * BAS_UBYTE(11u));
}
#line 359 "cpu.bas"
GET_STDOUT() << "Pregenerating signal lookup table...\r" << PrintCRLFtag{}; 
#line 361 "cpu.bas"
for(N_i = BAS_BYTE(0);N_i < BAS_INT(64);N_i += BAS_BYTE(1)) {
#line 361 "cpu.bas"
if(((N_i & BAS_UBYTE(15u)) >= BAS_UBYTE(14u))) {
#line 361 "cpu.bas"
R_i = BAS_UBYTE(29u);
} else {
#line 362 "cpu.bas"
R_i = N_i;
}
#line 365 "cpu.bas"
switch((R_i / BAS_UBYTE(16u))) {
case BAS_BYTE(0):;
#line 365 "cpu.bas"
M_i = BAS_UBYTE(22u);
#line 365 "cpu.bas"
Q_i = BAS_UBYTE(70u);
break;
case BAS_UBYTE(1u):;
#line 366 "cpu.bas"
M_i = BAS_UBYTE(33u);
#line 366 "cpu.bas"
Q_i = BAS_UBYTE(96u);
break;
case BAS_UBYTE(2u):;
#line 367 "cpu.bas"
M_i = BAS_UBYTE(62u);
#line 367 "cpu.bas"
Q_i = BAS_UBYTE(125u);
break;
case BAS_UBYTE(3u):;
#line 368 "cpu.bas"
M_i = BAS_UBYTE(99u);
#line 368 "cpu.bas"
Q_i = BAS_UBYTE(125u);
break;
}
#line 370 "cpu.bas"
if(((R_i & BAS_UBYTE(15u)) == BAS_UBYTE(13u))) {
#line 370 "cpu.bas"
Q_i = M_i;
} else {
#line 370 "cpu.bas"
if(((R_i & BAS_UBYTE(15u)) == BAS_BYTE(0))) {
#line 371 "cpu.bas"
M_i = Q_i;
}
}
#line 371 "cpu.bas"
SIGNALLO_i_a[N_i] = M_i;
#line 372 "cpu.bas"
SIGNALHI_i_a[N_i] = Q_i;
}
#line 381 "cpu.bas"
for(N_i = BAS_BYTE(0);N_i < BAS_INT(32);N_i += BAS_BYTE(1)) {
#line 381 "cpu.bas"
B_StmtREAD(APULENGTHS_i_a[N_i]);
}
#line 382 "cpu.bas"
for(N_i = BAS_BYTE(0);N_i < BAS_INT(16);N_i += BAS_BYTE(1)) {
#line 382 "cpu.bas"
B_StmtREAD(APUNOISEPERIODS_i_a[N_i]);
}
#line 383 "cpu.bas"
for(N_i = BAS_BYTE(0);N_i < BAS_INT(16);N_i += BAS_BYTE(1)) {
#line 383 "cpu.bas"
B_StmtREAD(APUPERIODSDMC_i_a[N_i]);
}
#line 385 "cpu.bas"
TURBOFACTOR_z = 1.f;
#line 452 "cpu.bas"
L5: ;
#line 452 "cpu.bas"
B_StmtREAD(N_i);
#line 452 "cpu.bas"
if((N_i <= BAS_BYTE(0))) {
#line 453 "cpu.bas"
goto L7;
}
#line 453 "cpu.bas"
B_StmtREAD(S_i, M_i, Q_i);
#line 454 "cpu.bas"
L6: ;
#line 454 "cpu.bas"
B_StmtREAD(R_i);
#line 455 "cpu.bas"
if((R_i < BAS_BYTE(0))) {
#line 455 "cpu.bas"
goto L5;
}
#line 455 "cpu.bas"
fstp0_i = S_i; fend0_i = ((R_i * BAS_INT(341)) + Q_i); for(R_i = ((R_i * BAS_INT(341)) + M_i);(fstp0_i > 0) ? (R_i <= fend0_i) : (R_i >= fend0_i);R_i += fstp0_i) {
#line 455 "cpu.bas"
COLUMNCATEGORIES_i_a[R_i] |= N_i;
}
#line 457 "cpu.bas"
goto L6;
#line 459 "cpu.bas"
L7: ;
#line 464 "cpu.bas"
SWAPFILEHANDLE_l = BAS_BYTE(-1);
#line 466 "cpu.bas"
CARTLOAD_f(
#line 466 "cpu.bas"
B_FuncCOMMAND_S());
#line 468 "cpu.bas"
B_OPEN("cpu.log",BAS_UBYTE(2u),2/*IN/OUT*/*16+2/*WRITE */);
#line 472 "cpu.bas"
GET_STDOUT() << "Pregenerating color lookup table...\r" << PrintCRLFtag{}; 
#line 473 "cpu.bas"
for(N_i = BAS_BYTE(-128);N_i <= BAS_INT(319);N_i += BAS_BYTE(1)) {
#line 474 "cpu.bas"
P_z = (N_i / (BAS_DBL)192.f);
#line 475 "cpu.bas"
if((P_z <= 0.0010000000474974513054f)) {
#line 477 "cpu.bas"
TRANSLATECOLOR_Y_a[(N_i)-(-128)] = BAS_BYTE(0);
} else {
#line 475 "cpu.bas"
if((P_z >= BAS_UBYTE(1u))) {
#line 479 "cpu.bas"
TRANSLATECOLOR_Y_a[(N_i)-(-128)] = BAS_UBYTE(255u);
} else {
#line 480 "cpu.bas"
TRANSLATECOLOR_Y_a[(N_i)-(-128)] = 
#line 480 "cpu.bas"
(BAS_INT)std::round((
#line 480 "cpu.bas"
std::exp((1.2220000028610229492f * 
#line 480 "cpu.bas"
std::log(P_z))) * BAS_UBYTE(255u)));
}
}
}
#line 484 "cpu.bas"
if(BAS_INT(0)) {
#line 486 "cpu.bas"
B_StmtSCREEN(BAS_UBYTE(13u));
#line 488 "cpu.bas"
L1: ;
#line 488 "cpu.bas"
B_StmtREAD(S_s);
#line 488 "cpu.bas"
M_i = 
#line 488 "cpu.bas"
B_FuncVAL(("&H" + S_s));
#line 488 "cpu.bas"
if((M_i == BAS_BYTE(0))) {
#line 489 "cpu.bas"
goto L4;
} else {
#line 489 "cpu.bas"
goto L3;
}
#line 489 "cpu.bas"
L2: ;
#line 489 "cpu.bas"
B_StmtOUT(M_i, (N_i & BAS_UBYTE(255u)));
#line 489 "cpu.bas"
B_StmtOUT((M_i + BAS_UBYTE(1u)), ((N_i / BAS_INT(256)) & BAS_UBYTE(255u)));
#line 490 "cpu.bas"
L3: ;
#line 490 "cpu.bas"
B_StmtREAD(S_s);
#line 490 "cpu.bas"
N_i = 
#line 490 "cpu.bas"
B_FuncVAL(("&H" + S_s));
#line 490 "cpu.bas"
if((N_i == BAS_BYTE(0))) {
#line 491 "cpu.bas"
goto L1;
} else {
#line 491 "cpu.bas"
goto L2;
}
#line 491 "cpu.bas"
L4: ;
#line 498 "cpu.bas"
GET_STDOUT() << "Pregenerating palette...\r" << PrintCRLFtag{}; 
#line 499 "cpu.bas"
B_StmtOUT(BAS_INT(968), BAS_BYTE(0));
#line 500 "cpu.bas"
for(N_i = BAS_UBYTE(1u);N_i <= BAS_UBYTE(5u);N_i += BAS_BYTE(1)) {
#line 501 "cpu.bas"
for(M_i = BAS_UBYTE(1u);M_i <= BAS_UBYTE(7u);M_i += BAS_BYTE(1)) {
#line 502 "cpu.bas"
for(Q_i = BAS_UBYTE(1u);Q_i <= BAS_UBYTE(7u);Q_i += BAS_BYTE(1)) {
#line 503 "cpu.bas"
B_StmtOUT(BAS_INT(969), (((N_i + BAS_BYTE(-1)) * BAS_UBYTE(63u)) / BAS_INT(4)));
#line 504 "cpu.bas"
B_StmtOUT(BAS_INT(969), (((M_i + BAS_BYTE(-1)) * BAS_UBYTE(63u)) / BAS_INT(6)));
#line 505 "cpu.bas"
B_StmtOUT(BAS_INT(969), (((Q_i + BAS_BYTE(-1)) * BAS_UBYTE(63u)) / BAS_INT(6)));
}
}
}
#line 508 "cpu.bas"
GET_STDOUT() << "Pregenerating dithering lookup table...\r" << PrintCRLFtag{}; 
#line 512 "cpu.bas"
for(N_i = BAS_BYTE(-128);N_i <= BAS_INT(319);N_i += BAS_BYTE(1)) {
#line 514 "cpu.bas"
for(M_i = BAS_BYTE(0);M_i < BAS_INT(4);M_i += BAS_BYTE(1)) {
#line 514 "cpu.bas"
R_i = BAS_INT(6);
#line 515 "cpu.bas"
Q_i = 
#line 515 "cpu.bas"
std::floor(((TRANSLATECOLOR_Y_a[(N_i)-(-128)] * (R_i / (BAS_DBL)255.f)) + (M_i / (BAS_DBL)BAS_UBYTE(4u))));
#line 515 "cpu.bas"
if((Q_i > R_i)) {
#line 516 "cpu.bas"
Q_i = R_i;
}
#line 517 "cpu.bas"
TRANSLATEBLUEBAYER_Y_a[(N_i)-(-128)][M_i] = Q_i;
#line 517 "cpu.bas"
R_i = BAS_INT(6);
#line 518 "cpu.bas"
Q_i = 
#line 518 "cpu.bas"
std::floor(((TRANSLATECOLOR_Y_a[(N_i)-(-128)] * (R_i / (BAS_DBL)255.f)) + (M_i / (BAS_DBL)BAS_UBYTE(4u))));
#line 518 "cpu.bas"
if((Q_i > R_i)) {
#line 519 "cpu.bas"
Q_i = R_i;
}
#line 519 "cpu.bas"
TRANSLATEGREENBAYER_Y_a[(N_i)-(-128)][M_i] = (Q_i * BAS_UBYTE(7u));
#line 520 "cpu.bas"
R_i = BAS_INT(4);
#line 521 "cpu.bas"
Q_i = 
#line 521 "cpu.bas"
std::floor(((TRANSLATECOLOR_Y_a[(N_i)-(-128)] * (R_i / (BAS_DBL)255.f)) + (M_i / (BAS_DBL)BAS_UBYTE(4u))));
#line 521 "cpu.bas"
if((Q_i > R_i)) {
#line 522 "cpu.bas"
Q_i = R_i;
}
#line 522 "cpu.bas"
TRANSLATEREDBAYER_Y_a[(N_i)-(-128)][M_i] = (Q_i * 49.);
}
}
} else {
#line 484 "cpu.bas"
if(BAS_INT(0)) {
#line 526 "cpu.bas"
B_StmtSCREEN(
#line 526 "cpu.bas"
B_Funcqb64NEWIMAGE(BAS_INT(1444), BAS_INT(524), BAS_UBYTE(32u)));
#line 526 "cpu.bas"
B_Stmtqb64DONTBLEND(BAS_BYTE(-1));
} else {
#line 484 "cpu.bas"
if(BAS_INT(-1)) {
#line 528 "cpu.bas"
B_StmtSCREEN(
#line 528 "cpu.bas"
B_Funcqb64NEWIMAGE(BAS_INT(640), BAS_INT(484), BAS_UBYTE(32u)));
#line 528 "cpu.bas"
B_Stmtqb64DONTBLEND(BAS_BYTE(-1));
#line 528 "cpu.bas"
B_Stmtqb64DISPLAY();
}
}
}
#line 533 "cpu.bas"
CPU_u.NZ_i = BAS_UBYTE(1u);
#line 534 "cpu.bas"
ADDR_i = BAS_INT(16407);
#line 534 "cpu.bas"
IOBYTE_Y = BAS_UBYTE(64u);
#line 534 "cpu.bas"
APUWRITE_f();
#line 535 "cpu.bas"
APU_u.NOISELFSR_i = BAS_UBYTE(1u);
#line 537 "cpu.bas"
SAMPLERATE_l = 
#line 538 "cpu.bas"
B_Funcqb64SNDRATE();
#line 539 "cpu.bas"
CPUEXECUTE_f(BAS_BYTE(0), BAS_UBYTE(76u));
#line 540 "cpu.bas"
if(BAS_INT(0)) {
#line 540 "cpu.bas"
CPU_u.PC_i = BAS_UINT(49151u);
#line 540 "cpu.bas"
PPU_u.COLUMN_i = BAS_INT(332);
#line 540 "cpu.bas"
PPU_u.ROW_i = BAS_UBYTE(240u);
#line 540 "cpu.bas"
CPUEXECUTE_f(BAS_BYTE(0), BAS_UBYTE(9u));
}
#line 543 "cpu.bas"
for(;;) {
#line 543 "cpu.bas"
CPUEXECUTE_f(CPUMODES_y_a[CPU_u.NEXTOPCODE_i], CPUOPS_y_a[CPU_u.NEXTOPCODE_i]);
}
#line 549 "cpu.bas"
B_StmtEND();
B_LibDone();
return 0;
B_ERR_FRAME_MAIN_END();
}


/* BODY OF SUB PPUSPRITEEVALUATION */
#line 2110 "cpu.bas"
void PPUSPRITEEVALUATION_f()
{
#line 2111 "cpu.bas"
BAS_UBYTE A_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 2112 "cpu.bas"
A_Y = OAM_Y_a[PPUGETOAMPOS_f()];
#line 2113 "cpu.bas"
if(((PPU_u.OAMPHASE_Y & BAS_UBYTE(7u)) == BAS_UBYTE(2u))) {
#line 2113 "cpu.bas"
A_Y |= BAS_UBYTE(4u);
}
#line 2114 "cpu.bas"
if(((PPU_u.OAMPHASE_Y & BAS_UBYTE(8u)) == BAS_BYTE(0))) {
#line 2114 "cpu.bas"
OAM2_Y_a[PPU_u.OAM2POS_Y] = A_Y;
}
#line 2116 "cpu.bas"
switch((PPU_u.OAMPHASE_Y & BAS_UBYTE(3u))) {
case BAS_BYTE(0):;
#line 2142 "cpu.bas"
if(((PPU_u.OAMPHASE_Y < BAS_UBYTE(16u)) && ((PPU_u.ROW_i >= A_Y) && (PPU_u.ROW_i < (A_Y + PPU_u.SPSIZE_Y))))) {
#line 2143 "cpu.bas"
if((PPU_u.OAMPHASE_Y & BAS_UBYTE(8u))) {
#line 2143 "cpu.bas"
PPU_u.SPOVERFLOW_Y = BAS_UBYTE(32u);
}
#line 2144 "cpu.bas"
PPUINCROAMPOSLO_f();
#line 2144 "cpu.bas"
PPUINCROAM2POS_f();
#line 2144 "cpu.bas"
PPU_u.OAMPHASE_Y = ((PPU_u.OAMPHASE_Y & BAS_UBYTE(28u)) | BAS_UBYTE(1u));
} else {
#line 2147 "cpu.bas"
PPU_u.OAMPHASE_Y |= BAS_UBYTE(4u);
#line 2148 "cpu.bas"
if((PPU_u.OAMPHASE_Y & BAS_UBYTE(8u))) {
#line 2148 "cpu.bas"
PPUINCROAMPOSLO_f();
}
#line 2149 "cpu.bas"
goto L2_L_OAMNEXTENTRYPLEASE;
}
break;
case BAS_UBYTE(1u):;
#line 2151 "cpu.bas"
PPUINCROAMPOSLO_f();
#line 2151 "cpu.bas"
PPUINCROAM2POS_f();
#line 2151 "cpu.bas"
PPU_u.OAMPHASE_Y = ((PPU_u.OAMPHASE_Y & BAS_UBYTE(28u)) | BAS_UBYTE(2u));
break;
case BAS_UBYTE(2u):;
#line 2152 "cpu.bas"
PPUINCROAMPOSLO_f();
#line 2152 "cpu.bas"
PPUINCROAM2POS_f();
#line 2152 "cpu.bas"
PPU_u.OAMPHASE_Y = ((PPU_u.OAMPHASE_Y & BAS_UBYTE(28u)) | BAS_UBYTE(3u));
break;
case BAS_UBYTE(3u):;
#line 2153 "cpu.bas"
PPUINCROAMPOSLO_f();
#line 2153 "cpu.bas"
PPUINCROAM2POS_f();
#line 2154 "cpu.bas"
PPU_u.OAMPHASE_Y = (((PPU_u.OAMPHASE_Y & BAS_UBYTE(28u)) | BAS_BYTE(0)) | BAS_UBYTE(4u));
#line 2156 "cpu.bas"
if((PPU_u.OAM2POS_Y == BAS_BYTE(0))) {
#line 2156 "cpu.bas"
PPU_u.OAMPHASE_Y |= BAS_UBYTE(8u);
}
#line 2158 "cpu.bas"
L2_L_OAMNEXTENTRYPLEASE: ;
#line 2159 "cpu.bas"
PPUINCROAMPOSHI_f();
#line 2161 "cpu.bas"
if((PPU_u.OAMPOSHI_Y == BAS_BYTE(0))) {
#line 2161 "cpu.bas"
PPU_u.OAMPHASE_Y |= BAS_UBYTE(16u);
}
break;
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUCOPYVERT */
#line 2062 "cpu.bas"
void PPUCOPYVERT_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2064 "cpu.bas"
PPU_u.YCOARSE_Y = PPU_u.YCOARSES_Y;
#line 2065 "cpu.bas"
PPU_u.YCOARSE32_i = (PPU_u.YCOARSE_Y * BAS_UBYTE(32u));
#line 2066 "cpu.bas"
PPU_u.FINEY_Y = PPU_u.FINEYS_Y;
#line 2067 "cpu.bas"
PPU_u.BASENTA_i = ((PPU_u.BASENTA_i & BAS_INT(1024)) | (PPU_u.BASENTAS_i & BAS_INT(2048)));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUINCRVADDRVERT */
#line 2048 "cpu.bas"
void PPUINCRVADDRVERT_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2049 "cpu.bas"
PPU_u.FINEY_Y = ((PPU_u.FINEY_Y + BAS_UBYTE(1u)) & BAS_UBYTE(7u));
#line 2049 "cpu.bas"
if((PPU_u.FINEY_Y != BAS_BYTE(0))) {
#line 2050 "cpu.bas"
goto subfunc_exit;
}
#line 2050 "cpu.bas"
PPU_u.YCOARSE_Y = ((PPU_u.YCOARSE_Y + BAS_UBYTE(1u)) & BAS_UBYTE(31u));
#line 2052 "cpu.bas"
if((PPU_u.YCOARSE_Y == BAS_UBYTE(30u))) {
#line 2052 "cpu.bas"
PPU_u.YCOARSE_Y = BAS_BYTE(0);
#line 2052 "cpu.bas"
PPU_u.BASENTA_i ^= BAS_INT(2048);
}
#line 2054 "cpu.bas"
PPU_u.YCOARSE32_i = (PPU_u.YCOARSE_Y * BAS_UBYTE(32u));
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB JOYREAD */
#line 1013 "cpu.bas"
void JOYREAD_f(BAS_UBYTE INDEX_Y)
{
B_ERR_FRAME_SUB_BEGIN();
#line 1014 "cpu.bas"
IOBYTE_Y = ((IOBYTE_Y & BAS_UBYTE(192u)) | (JOYNEXT_Y_a[INDEX_Y] & BAS_UBYTE(1u)));
#line 1015 "cpu.bas"
JOYNEXT_Y_a[INDEX_Y] = (JOYNEXT_Y_a[INDEX_Y] / BAS_UBYTE(2u));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB HEXS */
#line 1905 "cpu.bas"
std::string HEXS_f(BAS_ULONG VALUE_U, BAS_INT WID_i)
{
std::string FunctionReturn_s { };
#line 1906 "cpu.bas"
std::string S_s { };
B_ERR_FRAME_SUB_BEGIN();
#line 1907 "cpu.bas"
S_s = 
#line 1907 "cpu.bas"
B_FuncHEX_S(VALUE_U);
#line 1908 "cpu.bas"
if((
#line 1908 "cpu.bas"
(BAS_INT)std::round(BAS_ULONG((S_s).size())) >= WID_i)) {
#line 1908 "cpu.bas"
FunctionReturn_s = S_s;
} else {
#line 1908 "cpu.bas"
FunctionReturn_s = (
#line 1908 "cpu.bas"
B_FuncSTRING_S((WID_i - BAS_ULONG((S_s).size())), "0") + S_s);
}
    return FunctionReturn_s;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUREAD */
#line 1040 "cpu.bas"
void APUREAD_f()
{
#line 1041 "cpu.bas"
BAS_UBYTE N_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1042 "cpu.bas"
IOBYTE_Y = ((IOBYTE_Y & BAS_UBYTE(32u)) | (CPU_u.IRQ_i & BAS_UBYTE(192u)));
#line 1044 "cpu.bas"
for(N_Y = BAS_BYTE(0);N_Y < BAS_INT(5);N_Y += BAS_BYTE(1)) {
#line 1044 "cpu.bas"
if((APUCHANNELS_u_a[N_Y].LENGTHCOUNTER_Y != BAS_BYTE(0))) {
#line 1044 "cpu.bas"
IOBYTE_Y |= (BAS_UBYTE(1u) << N_Y);
}
}
#line 1046 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "APUread: IRQ=" << 
#line 1046 "cpu.bas"
B_FuncHEX_S(CPU_u.IRQ_i) << ";outcome=" << 
#line 1046 "cpu.bas"
B_FuncHEX_S(IOBYTE_Y) << PrintCRLFtag{}; 
#line 1047 "cpu.bas"
CPU_u.IRQ_i &= BAS_UBYTE(191u);
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUCOPYVADDR */
#line 2074 "cpu.bas"
void PPUCOPYVADDR_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2075 "cpu.bas"
PPU_u.XCOARSE_Y = PPU_u.XCOARSES_Y;
#line 2076 "cpu.bas"
PPU_u.YCOARSE_Y = PPU_u.YCOARSES_Y;
#line 2077 "cpu.bas"
PPU_u.YCOARSE32_i = (PPU_u.YCOARSE_Y * BAS_UBYTE(32u));
#line 2078 "cpu.bas"
PPU_u.BASENTA_i = PPU_u.BASENTAS_i;
#line 2079 "cpu.bas"
PPU_u.FINEY_Y = PPU_u.FINEYS_Y;
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUINCRVADDR2007 */
#line 2056 "cpu.bas"
void PPUINCRVADDR2007_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2057 "cpu.bas"
if((PPU_u.INC_Y == BAS_BYTE(0))) {
#line 2057 "cpu.bas"
PPU_u.XCOARSE_Y = ((PPU_u.XCOARSE_Y + BAS_UBYTE(1u)) & BAS_UBYTE(31u));
#line 2057 "cpu.bas"
if((PPU_u.XCOARSE_Y != BAS_BYTE(0))) {
#line 2058 "cpu.bas"
goto subfunc_exit;
}
}
#line 2058 "cpu.bas"
PPU_u.YCOARSE_Y = ((PPU_u.YCOARSE_Y + BAS_UBYTE(1u)) & BAS_UBYTE(31u));
#line 2058 "cpu.bas"
PPU_u.YCOARSE32_i = (PPU_u.YCOARSE_Y * BAS_UBYTE(32u));
#line 2058 "cpu.bas"
if((PPU_u.YCOARSE_Y != BAS_BYTE(0))) {
#line 2059 "cpu.bas"
goto subfunc_exit;
}
#line 2059 "cpu.bas"
PPU_u.BASENTA_i = ((PPU_u.BASENTA_i + BAS_INT(1024)) & BAS_INT(3072));
#line 2059 "cpu.bas"
if((PPU_u.BASENTA_i != BAS_BYTE(0))) {
#line 2060 "cpu.bas"
goto subfunc_exit;
}
#line 2060 "cpu.bas"
PPU_u.FINEY_Y = ((PPU_u.FINEY_Y + BAS_UBYTE(1u)) & BAS_UBYTE(7u));
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUMIXFUN */
#line 1385 "cpu.bas"
BAS_SGN APUMIXFUN_f(BAS_SGN M_z, BAS_SGN N_z, BAS_SGN D_z)
{
BAS_SGN FunctionReturn_z { };
B_ERR_FRAME_SUB_BEGIN();
#line 1386 "cpu.bas"
if((N_z != BAS_BYTE(0))) {
#line 1386 "cpu.bas"
FunctionReturn_z = (M_z / (BAS_DBL)N_z);
} else {
#line 1386 "cpu.bas"
FunctionReturn_z = D_z;
}
    return FunctionReturn_z;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CARTTICK */
#line 1861 "cpu.bas"
void CARTTICK_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 1862 "cpu.bas"
switch(MAPPERNUM_i) {
case BAS_UBYTE(9u):;
#line 1865 "cpu.bas"
switch((PPU_u.ADDRESSLINE_i & BAS_INT(16383))) {
case BAS_INT(4056):;
#line 1865 "cpu.bas"
MAPREG_Y_a[BAS_BYTE(0)] = BAS_BYTE(0);
#line 1865 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_BYTE(0), MAPREG_Y_a[BAS_UBYTE(2u)]);
break;
case BAS_INT(4072):;
#line 1866 "cpu.bas"
MAPREG_Y_a[BAS_BYTE(0)] = BAS_UBYTE(1u);
#line 1866 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_BYTE(0), MAPREG_Y_a[BAS_UBYTE(3u)]);
break;
case BAS_INT(8152) ... BAS_INT(8159):;
#line 1867 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(1u)] = BAS_BYTE(0);
#line 1867 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_UBYTE(16u), MAPREG_Y_a[BAS_UBYTE(4u)]);
break;
case BAS_INT(8168) ... BAS_INT(8175):;
#line 1868 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(1u)] = BAS_UBYTE(1u);
#line 1868 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_UBYTE(16u), MAPREG_Y_a[BAS_UBYTE(5u)]);
break;
}
break;
case BAS_UBYTE(4u):;
#line 1873 "cpu.bas"
if((PPU_u.ADDRESSLINE_i & BAS_INT(4096))) {
#line 1876 "cpu.bas"
if((MAPREG_Y_a[BAS_UBYTE(12u)] >= BAS_UBYTE(8u))) {
#line 1879 "cpu.bas"
if((MAPREG_Y_a[BAS_UBYTE(10u)] == BAS_BYTE(0))) {
#line 1879 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(10u)] = MAPREG_Y_a[BAS_UBYTE(9u)];
} else {
#line 1881 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(10u)] += BAS_BYTE(-1);
#line 1882 "cpu.bas"
if(((MAPREG_Y_a[BAS_UBYTE(10u)] == BAS_BYTE(0)) && (MAPREG_Y_a[BAS_UBYTE(11u)] != BAS_BYTE(0)))) {
#line 1882 "cpu.bas"
CPU_u.IRQ_i |= BAS_UBYTE(1u);
}
}
}
#line 1891 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(12u)] = BAS_BYTE(0);
} else {
#line 1873 "cpu.bas"
if((MAPREG_Y_a[BAS_UBYTE(12u)] < BAS_UBYTE(8u))) {
#line 1893 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(12u)] += BAS_UBYTE(1u);
}
}
break;
case BAS_UBYTE(10u):;
#line 1897 "cpu.bas"
switch((PPU_u.ADDRESSLINE_i & BAS_INT(16383))) {
case BAS_INT(4048) ... BAS_INT(4063):;
#line 1897 "cpu.bas"
MAPREG_Y_a[BAS_BYTE(0)] = BAS_BYTE(0);
#line 1897 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_BYTE(0), MAPREG_Y_a[BAS_UBYTE(2u)]);
break;
case BAS_INT(4064) ... BAS_INT(4079):;
#line 1898 "cpu.bas"
MAPREG_Y_a[BAS_BYTE(0)] = BAS_UBYTE(1u);
#line 1898 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_BYTE(0), MAPREG_Y_a[BAS_UBYTE(3u)]);
break;
case BAS_INT(8144) ... BAS_INT(8159):;
#line 1899 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(1u)] = BAS_BYTE(0);
#line 1899 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_UBYTE(16u), MAPREG_Y_a[BAS_UBYTE(4u)]);
break;
case BAS_INT(8160) ... BAS_INT(8175):;
#line 1900 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(1u)] = BAS_UBYTE(1u);
#line 1900 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_UBYTE(16u), MAPREG_Y_a[BAS_UBYTE(5u)]);
break;
}
break;
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CARTLOAD */
#line 1424 "cpu.bas"
void CARTLOAD_f(const std::string &F_s)
{
#line 1426 "cpu.bas"
BAS_INT VRAM1COUNT_i { };
#line 1426 "cpu.bas"
BAS_INT CTRLBYTE_i { };
#line 1426 "cpu.bas"
BAS_INT VROM8COUNT_i { };
#line 1426 "cpu.bas"
BAS_INT ROM16COUNT_i { };
#line 1425 "cpu.bas"
BAS_LNG FD_l { };
#line 1425 "cpu.bas"
BAS_LNG A_l { };
#line 1425 "cpu.bas"
BAS_UBYTE B_Y { };
// Automatically added temporaries:
BAS_LNG fend1_l { };
BAS_LNG fend2_l { };
B_ERR_FRAME_SUB_BEGIN();
#line 1427 "cpu.bas"
GET_STDOUT() << "Loading ROM..."; 
#line 1429 "cpu.bas"
if((SWAPFILEHANDLE_l >= BAS_BYTE(0))) {
#line 1429 "cpu.bas"
B_StmtCLOSE(SWAPFILEHANDLE_l);
}
#line 1431 "cpu.bas"
FD_l = 
#line 1432 "cpu.bas"
B_FuncFREEFILE();
#line 1432 "cpu.bas"
B_OPEN(F_s,FD_l,2/*IN/OUT*/*16+1/*READ */);
#line 1432 "cpu.bas"
B_StmtCLOSE(FD_l);
#line 1433 "cpu.bas"
B_OPEN(F_s,FD_l,1/*RANDOM*/*16+1/*READ */,BAS_UBYTE(16u));
#line 1435 "cpu.bas"
B_StmtFIELD(BAS_UBYTE(1u), BAS_UBYTE(16u), BS_s);
#line 1436 "cpu.bas"
B_StmtGET(BAS_UBYTE(1u));
#line 1438 "cpu.bas"
if((BS_s.compare(0, 4, "NES\32", 4)!=0)) {
#line 1438 "cpu.bas"
B_StmtERROR(BAS_UBYTE(13u));
#line 1440 "cpu.bas"
goto subfunc_exit;
}
#line 1440 "cpu.bas"
B_Y = B_ASC_MID(BS_s, BAS_UBYTE(5u));
#line 1440 "cpu.bas"
ROM16COUNT_i = B_Y;
#line 1441 "cpu.bas"
B_Y = B_ASC_MID(BS_s, BAS_UBYTE(6u));
#line 1441 "cpu.bas"
VROM8COUNT_i = B_Y;
#line 1442 "cpu.bas"
B_Y = B_ASC_MID(BS_s, BAS_UBYTE(7u));
#line 1442 "cpu.bas"
CTRLBYTE_i = B_Y;
#line 1443 "cpu.bas"
B_Y = B_ASC_MID(BS_s, BAS_UBYTE(8u));
#line 1443 "cpu.bas"
MAPPERNUM_i = ((B_Y & BAS_UBYTE(240u)) | (CTRLBYTE_i / BAS_UBYTE(16u)));
#line 1444 "cpu.bas"
GET_STDOUT() << "iNES MAPPER NUMBER:  " << MAPPERNUM_i << ' ' << PrintCRLFtag{}; 
#line 1445 "cpu.bas"
GET_STDOUT() << "PRG-ROM:  " << (ROM16COUNT_i * BAS_UBYTE(16u)) << "  kB" << PrintCRLFtag{}; 
#line 1446 "cpu.bas"
GET_STDOUT() << "CHR-ROM:  " << (VROM8COUNT_i * BAS_UBYTE(16u)) << "  kB" << PrintCRLFtag{}; 
#line 1448 "cpu.bas"
PRGSIZEPAGES_i = (ROM16COUNT_i * BAS_UBYTE(64u));
#line 1449 "cpu.bas"
CHRSIZEPAGES_i = (VROM8COUNT_i * BAS_UBYTE(32u));
#line 1451 "cpu.bas"
if(BAS_BYTE(0)) {
#line 1453 "cpu.bas"
SWAPFILEHANDLE_l = FD_l;
#line 1455 "cpu.bas"
SWAPPRGBASIS_l = BAS_UBYTE(2u);
#line 1456 "cpu.bas"
SWAPCHRBASIS_l = (SWAPPRGBASIS_l + (
#line 1456 "cpu.bas"
(BAS_LNG)std::round(ROM16COUNT_i) * 1024));
#line 1459 "cpu.bas"
A_l = ((BAS_UINT(32768u) / BAS_ULONG(sizeof(CPU_u.CYCLECOUNTER_Y))) + BAS_BYTE(-1));
#line 1459 "cpu.bas"
GET_STDOUT() << "PRG memory: Allocating  " << (A_l + BAS_UBYTE(1u)) << "  bytes\r" << PrintCRLFtag{}; 
#line 1460 "cpu.bas"
PRGROM_Y_a.Redim(0,1, BAS_BYTE(0), A_l);
#line 1461 "cpu.bas"
A_l = BAS_INT(8191);
#line 1461 "cpu.bas"
GET_STDOUT() << "CHR memory: Allocating  " << (A_l + BAS_UBYTE(1u)) << "  bytes\r" << PrintCRLFtag{}; 
#line 1462 "cpu.bas"
CHRROM_Y_a.Redim(0,1, BAS_BYTE(0), A_l);
#line 1465 "cpu.bas"
for(B_Y = BAS_BYTE(0);B_Y < BAS_INT(8);B_Y += BAS_BYTE(1)) {
#line 1465 "cpu.bas"
CHRBANKS_l_a[B_Y] = BAS_BYTE(-1);
#line 1465 "cpu.bas"
PRGBANKS_l_a[B_Y] = BAS_BYTE(-1);
}
} else {
#line 1467 "cpu.bas"
VRAM1COUNT_i = (VROM8COUNT_i * BAS_UBYTE(8u));
#line 1468 "cpu.bas"
if((VRAM1COUNT_i == BAS_BYTE(0))) {
#line 1468 "cpu.bas"
VRAM1COUNT_i = BAS_UBYTE(8u);
}
#line 1470 "cpu.bas"
A_l = ((
#line 1470 "cpu.bas"
(BAS_LNG)std::round(ROM16COUNT_i) * 16384) - 1);
#line 1470 "cpu.bas"
GET_STDOUT() << "PRG memory: Allocating  " << (A_l + BAS_UBYTE(1u)) << "  bytes\r" << PrintCRLFtag{}; 
#line 1471 "cpu.bas"
PRGROM_Y_a.Redim(0,1, BAS_BYTE(0), A_l);
#line 1472 "cpu.bas"
A_l = ((
#line 1472 "cpu.bas"
(BAS_LNG)std::round(VRAM1COUNT_i) * 1024) - 1);
#line 1472 "cpu.bas"
GET_STDOUT() << "CHR memory: Allocating  " << (A_l + BAS_UBYTE(1u)) << "  bytes\r" << PrintCRLFtag{}; 
#line 1473 "cpu.bas"
CHRROM_Y_a.Redim(0,1, BAS_BYTE(0), A_l);
#line 1482 "cpu.bas"
fend1_l = (
#line 1481 "cpu.bas"
(BAS_LNG)std::round(ROM16COUNT_i) * 1024); for(A_l = BAS_UBYTE(1u);A_l <= fend1_l;A_l += BAS_BYTE(1)) {
#line 1482 "cpu.bas"
B_StmtGET(BAS_UBYTE(1u));
#line 1483 "cpu.bas"
for(B_Y = BAS_UBYTE(1u);B_Y <= BAS_UBYTE(16u);B_Y += BAS_BYTE(1)) {
#line 1483 "cpu.bas"
PRGROM_Y_a.Index(0,0,(((A_l * BAS_UBYTE(16u)) + B_Y) + BAS_BYTE(-17))) = B_ASC_MID(BS_s, B_Y);
}
}
#line 1487 "cpu.bas"
fend2_l = (
#line 1486 "cpu.bas"
(BAS_LNG)std::round(VROM8COUNT_i) * 512); for(A_l = BAS_UBYTE(1u);A_l <= fend2_l;A_l += BAS_BYTE(1)) {
#line 1487 "cpu.bas"
B_StmtGET(BAS_UBYTE(1u));
#line 1488 "cpu.bas"
for(B_Y = BAS_UBYTE(1u);B_Y <= BAS_UBYTE(16u);B_Y += BAS_BYTE(1)) {
#line 1488 "cpu.bas"
CHRROM_Y_a.Index(0,0,(((A_l * BAS_UBYTE(16u)) + B_Y) + BAS_BYTE(-17))) = B_ASC_MID(BS_s, B_Y);
}
}
#line 1490 "cpu.bas"
B_StmtCLOSE(FD_l);
}
#line 1494 "cpu.bas"
switch((CTRLBYTE_i & BAS_UBYTE(9u))) {
case BAS_UBYTE(8u):;
case BAS_UBYTE(9u):;
#line 1494 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(1672));
break;
case BAS_UBYTE(1u):;
#line 1495 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(520));
break;
default:;
#line 1496 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(576));
}
#line 1500 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), BAS_BYTE(0));
#line 1501 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(64u), BAS_BYTE(0));
#line 1502 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), BAS_BYTE(0));
#line 1503 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), BAS_BYTE(-1));
#line 1504 "cpu.bas"
if((MAPPERNUM_i == BAS_UBYTE(1u))) {
#line 1505 "cpu.bas"
MAPREG_Y_a[BAS_BYTE(0)] = BAS_UBYTE(31u);
}
#line 1505 "cpu.bas"
if((MAPPERNUM_i == BAS_UBYTE(9u))) {
#line 1505 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(32u), BAS_UBYTE(160u), BAS_BYTE(-3));
}
#line 1506 "cpu.bas"
if((MAPPERNUM_i == BAS_UBYTE(41u))) {
#line 1506 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), BAS_BYTE(0));
}
#line 1509 "cpu.bas"
if((((MAPPERNUM_i == BAS_UBYTE(174u)) || (MAPPERNUM_i == BAS_UBYTE(227u))) || (MAPPERNUM_i == BAS_UBYTE(58u)))) {
#line 1509 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), BAS_BYTE(0));
#line 1509 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(520));
}
#line 1510 "cpu.bas"
GET_STDOUT() << " done" << PrintCRLFtag{}; 
#line 1512 "cpu.bas"
goto subfunc_exit;
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB DUMMYRB */
#line 897 "cpu.bas"
void DUMMYRB_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 898 "cpu.bas"
MEMACCESS_f(BAS_BYTE(0));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB INCADDR */
#line 877 "cpu.bas"
BAS_INT INCADDR_f(BAS_INT HOW_i)
{
BAS_INT FunctionReturn_i { };
#line 878 "cpu.bas"
BAS_INT SUM_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 879 "cpu.bas"
SUM_i = (ADDR_i + HOW_i);
#line 880 "cpu.bas"
ADDR_i = ((ADDR_i & BAS_UINT(65280u)) | (SUM_i & BAS_UBYTE(255u)));
#line 881 "cpu.bas"
FunctionReturn_i = (SUM_i - ADDR_i);
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUINCROAMPOS */
#line 2012 "cpu.bas"
void PPUINCROAMPOS_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2014 "cpu.bas"
PPUINCROAMPOSLO_f();
#line 2015 "cpu.bas"
if((PPU_u.OAMPOSLO_Y == BAS_BYTE(0))) {
#line 2015 "cpu.bas"
PPUINCROAMPOSHI_f();
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUTICKDOIO */
#line 2279 "cpu.bas"
void PPUTICKDOIO_f()
{
#line 2280 "cpu.bas"
BAS_INT A_i { };
#line 2280 "cpu.bas"
BAS_UBYTE B_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 2282 "cpu.bas"
if(((PPU_u.ADDRESSLINE_i & BAS_INT(16384)) == BAS_BYTE(0))) {
#line 2282 "cpu.bas"
goto subfunc_exit;
}
#line 2286 "cpu.bas"
if((PPU_u.ADDRESSLINE_i & BAS_INT(8192))) {
#line 2287 "cpu.bas"
A_i = (PPU_u.ADDRESSLINE_i & BAS_INT(16383));
#line 2289 "cpu.bas"
if((PPU_u.ADDRESSLINE_i & BAS_UINT(32768u))) {
#line 2290 "cpu.bas"
NRAM_Y_a[(NTA_i_a[((A_i / BAS_INT(1024)) & BAS_UBYTE(3u))] + (A_i & BAS_INT(1023)))] = (PPU_u.READBUFFER_i & BAS_UBYTE(255u));
} else {
#line 2292 "cpu.bas"
B_Y = NRAM_Y_a[(NTA_i_a[((A_i / BAS_INT(1024)) & BAS_UBYTE(3u))] + (A_i & BAS_INT(1023)))];
}
} else {
#line 2295 "cpu.bas"
if(BAS_BYTE(0)) {
#line 2296 "cpu.bas"
if((PPU_u.ADDRESSLINE_i & BAS_UINT(32768u))) {
#line 2297 "cpu.bas"
CHRROM_Y_a.Index(0,0,(PPU_u.ADDRESSLINE_i & BAS_INT(8191))) = (PPU_u.READBUFFER_i & BAS_UBYTE(255u));
} else {
#line 2299 "cpu.bas"
B_Y = CHRROM_Y_a.Index(0,0,(PPU_u.ADDRESSLINE_i & BAS_INT(8191)));
}
} else {
#line 2302 "cpu.bas"
A_i = (PPU_u.ADDRESSLINE_i & BAS_INT(16383));
#line 2303 "cpu.bas"
if((PPU_u.ADDRESSLINE_i & BAS_UINT(32768u))) {
#line 2304 "cpu.bas"
CHRROM_Y_a.Index(0,0,(CHRBANKS_l_a[(A_i / BAS_INT(1024))] + (A_i & BAS_INT(1023)))) = (PPU_u.READBUFFER_i & BAS_UBYTE(255u));
} else {
#line 2306 "cpu.bas"
B_Y = CHRROM_Y_a.Index(0,0,(CHRBANKS_l_a[(A_i / BAS_INT(1024))] + (A_i & BAS_INT(1023))));
}
}
}
#line 2311 "cpu.bas"
PPU_u.ADDRESSLINE_i = ((PPU_u.ADDRESSLINE_i & BAS_INT(16128)) | B_Y);
#line 2312 "cpu.bas"
if((PPU_u.READBUFFER_i & BAS_INT(256))) {
#line 2312 "cpu.bas"
PPU_u.READBUFFER_i = B_Y;
}
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB MEMACCESS */
#line 962 "cpu.bas"
void MEMACCESS_f(BAS_INT W_i)
{
#line 991 "cpu.bas"
BAS_INT C_i { };
#line 991 "cpu.bas"
BAS_INT A_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 966 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 966 "cpu.bas"
CPUTICK_f(BAS_BYTE(0));
}
#line 968 "cpu.bas"
if(BAS_INT(0)) {
#line 968 "cpu.bas"
if(W_i) {
#line 968 "cpu.bas"
UsingFormatter ("Writes \\\\ to \\  \\").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f(IOBYTE_Y, BAS_UBYTE(2u)), HEXS_f((
#line 968 "cpu.bas"
(BAS_LNG)std::round(ADDR_i) & 65535), BAS_UBYTE(4u))) << PrintCRLFtag{}; 
}
}
#line 970 "cpu.bas"
if((ADDR_i & BAS_UINT(32768u))) {
#line 971 "cpu.bas"
CARTACCESS_f(W_i);
} else {
#line 970 "cpu.bas"
if((ADDR_i < BAS_INT(8192))) {
#line 974 "cpu.bas"
if(W_i) {
#line 974 "cpu.bas"
RAM_Y_a[(ADDR_i & BAS_INT(2047))] = IOBYTE_Y;
} else {
#line 974 "cpu.bas"
IOBYTE_Y = RAM_Y_a[(ADDR_i & BAS_INT(2047))];
}
} else {
#line 970 "cpu.bas"
if((ADDR_i < BAS_INT(16384))) {
#line 977 "cpu.bas"
if((W_i != BAS_BYTE(0))) {
#line 977 "cpu.bas"
PPUIOBYTE_Y = IOBYTE_Y;
}
#line 978 "cpu.bas"
PPUACCESS_f(W_i);
#line 979 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 979 "cpu.bas"
IOBYTE_Y = PPUIOBYTE_Y;
}
} else {
#line 970 "cpu.bas"
if((ADDR_i <= BAS_INT(16403))) {
#line 982 "cpu.bas"
if(W_i) {
#line 983 "cpu.bas"
APUWRITE_f();
}
} else {
#line 970 "cpu.bas"
if((ADDR_i >= BAS_INT(16408))) {
#line 984 "cpu.bas"
CARTACCESS_f(W_i);
} else {
#line 986 "cpu.bas"
switch((ADDR_i - BAS_INT(16404))) {
case BAS_UBYTE(1u):;
#line 986 "cpu.bas"
goto L3_L_A4015;
break;
case BAS_UBYTE(2u):;
#line 986 "cpu.bas"
goto L4_L_A4016;
break;
case BAS_UBYTE(3u):;
#line 986 "cpu.bas"
goto L5_L_A4017;
break;
}
#line 988 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 988 "cpu.bas"
goto L6_L_DONEADDR;
}
#line 990 "cpu.bas"
do {
#line 990 "cpu.bas"
CPUTICK_f(BAS_UBYTE(1u));
#line 990 "cpu.bas"
} while(((CPU_u.CYCLECOUNTER_Y & BAS_UBYTE(1u)) == BAS_BYTE(0)));
#line 992 "cpu.bas"
C_i = ((IOBYTE_Y & BAS_UBYTE(7u)) * 256u);
#line 994 "cpu.bas"
for(A_i = BAS_BYTE(0);A_i < BAS_INT(256);A_i += BAS_BYTE(1)) {
#line 994 "cpu.bas"
ADDR_i = (C_i + A_i);
#line 994 "cpu.bas"
MEMACCESS_f(BAS_BYTE(0));
#line 995 "cpu.bas"
ADDR_i = BAS_INT(8196);
#line 995 "cpu.bas"
MEMACCESS_f(BAS_UBYTE(1u));
}
#line 997 "cpu.bas"
goto L6_L_DONEADDR;
#line 998 "cpu.bas"
L3_L_A4015: ;
#line 999 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 999 "cpu.bas"
APUREAD_f();
} else {
#line 1000 "cpu.bas"
APUWRITE_f();
}
#line 1000 "cpu.bas"
goto L6_L_DONEADDR;
#line 1001 "cpu.bas"
L4_L_A4016: ;
#line 1002 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 1002 "cpu.bas"
JOYREAD_f(BAS_BYTE(0));
} else {
#line 1002 "cpu.bas"
JOYSTROBE_f(IOBYTE_Y);
}
#line 1003 "cpu.bas"
goto L6_L_DONEADDR;
#line 1004 "cpu.bas"
L5_L_A4017: ;
#line 1005 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 1005 "cpu.bas"
JOYREAD_f(BAS_UBYTE(1u));
} else {
#line 1006 "cpu.bas"
APUWRITE_f();
}
}
}
}
}
}
#line 1009 "cpu.bas"
L6_L_DONEADDR: ;
#line 1009 "cpu.bas"
if(BAS_INT(0)) {
#line 1009 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 1009 "cpu.bas"
UsingFormatter ("Reads from \\  \\ -> \\\\").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f((
#line 1009 "cpu.bas"
(BAS_LNG)std::round(ADDR_i) & 65535), BAS_UBYTE(4u)), HEXS_f(IOBYTE_Y, BAS_UBYTE(2u))) << PrintCRLFtag{}; 
}
}
#line 1010 "cpu.bas"
if((W_i != BAS_BYTE(0))) {
#line 1010 "cpu.bas"
CPUTICK_f(BAS_UBYTE(1u));
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUFRAMETICK */
#line 1164 "cpu.bas"
void APUFRAMETICK_f()
{
#line 1205 "cpu.bas"
BAS_INT S_i { };
#line 1205 "cpu.bas"
BAS_INT WL_i { };
#line 1205 "cpu.bas"
BAS_UBYTE N_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1187 "cpu.bas"
switch(APU_u.FRAME_Y) {
case BAS_BYTE(0):;
#line 1188 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(1u);
#line 1188 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(7456);
#line 1188 "cpu.bas"
goto L7_L_NOCLOCKLENGTH;
break;
case BAS_UBYTE(1u):;
#line 1189 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(2u);
#line 1189 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(7458);
break;
case BAS_UBYTE(2u):;
#line 1190 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(3u);
#line 1190 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(7457);
#line 1190 "cpu.bas"
goto L7_L_NOCLOCKLENGTH;
break;
case BAS_UBYTE(3u):;
#line 1191 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(4u);
#line 1191 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_UBYTE(1u);
#line 1191 "cpu.bas"
if(APU_u.IRQDISABLE_Y) {
#line 1191 "cpu.bas"
goto subfunc_exit;
} else {
#line 1191 "cpu.bas"
CPU_u.IRQ_i |= BAS_UBYTE(64u);
#line 1192 "cpu.bas"
goto subfunc_exit;
}
break;
case BAS_UBYTE(4u):;
#line 1192 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(5u);
#line 1192 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_UBYTE(1u);
#line 1192 "cpu.bas"
if((!APU_u.IRQDISABLE_Y)) {
#line 1192 "cpu.bas"
CPU_u.IRQ_i |= BAS_UBYTE(64u);
}
break;
case BAS_UBYTE(5u):;
#line 1193 "cpu.bas"
APU_u.FRAME_Y = BAS_BYTE(0);
#line 1193 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(7457);
#line 1193 "cpu.bas"
if(APU_u.IRQDISABLE_Y) {
#line 1193 "cpu.bas"
goto subfunc_exit;
} else {
#line 1193 "cpu.bas"
CPU_u.IRQ_i |= BAS_UBYTE(64u);
#line 1195 "cpu.bas"
goto subfunc_exit;
}
break;
case BAS_UBYTE(6u):;
#line 1196 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(7u);
#line 1196 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(7458);
break;
case BAS_UBYTE(7u):;
#line 1197 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(8u);
#line 1197 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(7456);
#line 1197 "cpu.bas"
goto L7_L_NOCLOCKLENGTH;
break;
case BAS_UBYTE(8u):;
#line 1198 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(9u);
#line 1198 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(7458);
break;
case BAS_UBYTE(9u):;
#line 1199 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(6u);
#line 1199 "cpu.bas"
APU_u.FRAMEDELAY_i = BAS_INT(14910);
#line 1199 "cpu.bas"
goto L7_L_NOCLOCKLENGTH;
break;
}
#line 1207 "cpu.bas"
for(N_Y = BAS_BYTE(0);N_Y < BAS_INT(4);N_Y += BAS_BYTE(1)) {
#line 1208 "cpu.bas"
if(((APUCHANNELS_u_a[N_Y].LENGTHCOUNTER_Y != BAS_BYTE(0)) && (APUCHANNELS_u_a[N_Y].LENGTHCOUNTERDISABLE_Y == BAS_BYTE(0)))) {
#line 1208 "cpu.bas"
APUCHANNELS_u_a[N_Y].LENGTHCOUNTER_Y -= BAS_UBYTE(1u);
}
}
#line 1214 "cpu.bas"
for(N_Y = BAS_BYTE(0);N_Y < BAS_INT(2);N_Y += BAS_BYTE(1)) {
#line 1215 "cpu.bas"
if((APUCHANNELS_u_a[N_Y].SWEEPDELAY_Y > BAS_BYTE(0))) {
#line 1215 "cpu.bas"
APUCHANNELS_u_a[N_Y].SWEEPDELAY_Y -= BAS_UBYTE(1u);
} else {
#line 1217 "cpu.bas"
APUCHANNELS_u_a[N_Y].SWEEPDELAY_Y = APUCHANNELS_u_a[N_Y].SWEEPRATE_Y;
#line 1218 "cpu.bas"
WL_i = APUCHANNELS_u_a[N_Y].WAVELENGTH_i;
#line 1220 "cpu.bas"
if((((WL_i >= BAS_UBYTE(8u)) && (APUCHANNELS_u_a[N_Y].SWEEPENABLE_Y != BAS_BYTE(0))) && (APUCHANNELS_u_a[N_Y].SWEEPSHIFT_Y != BAS_BYTE(0)))) {
#line 1220 "cpu.bas"
S_i = (WL_i >> APUCHANNELS_u_a[N_Y].SWEEPSHIFT_Y);
#line 1224 "cpu.bas"
if((APUCHANNELS_u_a[N_Y].SWEEPDECREASE_Y != BAS_BYTE(0))) {
#line 1224 "cpu.bas"
WL_i += (~(S_i + N_Y));
} else {
#line 1224 "cpu.bas"
WL_i += S_i;
}
#line 1225 "cpu.bas"
if((WL_i < BAS_INT(2048))) {
#line 1225 "cpu.bas"
APUCHANNELS_u_a[N_Y].WAVELENGTH_i = WL_i;
}
}
}
}
#line 1231 "cpu.bas"
L7_L_NOCLOCKLENGTH: ;
#line 1234 "cpu.bas"
if((APUCHANNELS_u_a[BAS_UBYTE(2u)].LENGTHCOUNTERDISABLE_Y != BAS_BYTE(0))) {
#line 1234 "cpu.bas"
APU_u.LINEARCOUNTER_Y = APU_u.LINEARCOUNTERINIT_Y;
} else {
#line 1234 "cpu.bas"
if((APU_u.LINEARCOUNTER_Y > BAS_BYTE(0))) {
#line 1236 "cpu.bas"
APU_u.LINEARCOUNTER_Y += BAS_BYTE(-1);
}
}
#line 1240 "cpu.bas"
for(N_Y = BAS_BYTE(0);N_Y < BAS_INT(4);N_Y += BAS_BYTE(1)) {
#line 1241 "cpu.bas"
if(((N_Y != BAS_UBYTE(2u)) && (APUCHANNELS_u_a[N_Y].ENVDECAYDISABLE_Y == BAS_BYTE(0)))) {
#line 1242 "cpu.bas"
if((APUCHANNELS_u_a[N_Y].ENVDELAY_Y > BAS_BYTE(0))) {
#line 1242 "cpu.bas"
APUCHANNELS_u_a[N_Y].ENVDELAY_Y += BAS_BYTE(-1);
} else {
#line 1244 "cpu.bas"
APUCHANNELS_u_a[N_Y].ENVDELAY_Y = APUCHANNELS_u_a[N_Y].ENVDECAYRATE_Y;
#line 1246 "cpu.bas"
if(((APUCHANNELS_u_a[N_Y].ENVELOPE_Y > BAS_BYTE(0)) || (APUCHANNELS_u_a[N_Y].ENVDECAYLOOPENABLE_Y != BAS_BYTE(0)))) {
#line 1246 "cpu.bas"
APUCHANNELS_u_a[N_Y].ENVELOPE_Y = ((APUCHANNELS_u_a[N_Y].ENVELOPE_Y - BAS_UBYTE(1u)) & BAS_UBYTE(15u));
}
}
}
}
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUTICK */
#line 2317 "cpu.bas"
void PPUTICK_f()
{
#line 2592 "cpu.bas"
BAS_SGN CURTIMER_z { };
#line 2591 "cpu.bas"
static BAS_SGN SKIPTREND_z { };
#line 2591 "cpu.bas"
static BAS_SGN PREVTIMER_z { };
#line 2614 "cpu.bas"
BAS_SGN I_z { };
#line 2591 "cpu.bas"
static BAS_SGN TIMINGSUM_z { };
#line 2592 "cpu.bas"
BAS_DBL TARGETRATE_d { };
#line 2592 "cpu.bas"
BAS_DBL RATE_d { };
#line 2551 "cpu.bas"
static BAS_INT SKIPCOUNTER_i { };
#line 2499 "cpu.bas"
BAS_INT SPRITENO_i { };
#line 2391 "cpu.bas"
BAS_INT C_i { };
#line 2326 "cpu.bas"
BAS_INT CATEGORY_i { };
#line 2479 "cpu.bas"
BAS_BYTE SHOWSP_y { };
#line 2422 "cpu.bas"
BAS_UINT C_I { };
#line 2555 "cpu.bas"
BAS_ULONG RGB_U { };
#line 2590 "cpu.bas"
static BAS_UBYTE FRAMECOUNTER_Y { };
#line 2505 "cpu.bas"
BAS_UBYTE BOTH_Y { };
#line 2479 "cpu.bas"
BAS_UBYTE PIX_Y { };
#line 2406 "cpu.bas"
BAS_UBYTE B_Y { };
#line 2377 "cpu.bas"
BAS_UBYTE A_Y { };
// Automatically added temporaries:
BAS_INT fend3_i { };
BAS_INT selv0_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2318 "cpu.bas"
CARTTICK_f();
#line 2321 "cpu.bas"
if(((PPU_u.COLUMN_i & BAS_UBYTE(1u)) == BAS_BYTE(0))) {
#line 2321 "cpu.bas"
PPUTICKDOIO_f();
}
#line 2328 "cpu.bas"
CATEGORY_i = COLUMNCATEGORIES_i_a[(PPU_u.COLUMN_i + PPU_u.ROWCLASS_i)];
#line 2331 "cpu.bas"
if((CATEGORY_i & BAS_INT(256))) {
#line 2335 "cpu.bas"
PPU_u.OAMPOSLO_Y = BAS_BYTE(0);
#line 2336 "cpu.bas"
PPU_u.OAMPOSHI_Y = BAS_BYTE(0);
#line 2337 "cpu.bas"
PPU_u.OAMPHASE_Y = BAS_BYTE(0);
#line 2338 "cpu.bas"
PPU_u.OAM2POS_Y = ((PPU_u.COLUMN_i / BAS_UBYTE(2u)) & BAS_UBYTE(31u));
#line 2339 "cpu.bas"
OAM2_Y_a[PPU_u.OAM2POS_Y] = BAS_UBYTE(255u);
}
#line 2342 "cpu.bas"
if((CATEGORY_i & BAS_INT(512))) {
#line 2343 "cpu.bas"
PPUSPRITEEVALUATION_f();
}
#line 2345 "cpu.bas"
if((CATEGORY_i & BAS_INT(1024))) {
#line 2347 "cpu.bas"
PPU_u.SHIFTPAT1_i |= PPU_u.TILEPAT1_Y;
#line 2348 "cpu.bas"
PPU_u.SHIFTPAT2_i |= PPU_u.TILEPAT2_Y;
#line 2349 "cpu.bas"
if((PPU_u.TILEATTR_Y & BAS_UBYTE(1u))) {
#line 2349 "cpu.bas"
PPU_u.SHIFTATTR1_i |= BAS_UBYTE(255u);
}
#line 2350 "cpu.bas"
if((PPU_u.TILEATTR_Y & BAS_UBYTE(2u))) {
#line 2350 "cpu.bas"
PPU_u.SHIFTATTR2_i |= BAS_UBYTE(255u);
}
}
#line 2352 "cpu.bas"
switch((CATEGORY_i / BAS_INT(2048))) {
case BAS_UBYTE(1u):;
#line 2352 "cpu.bas"
goto L8_L_SETNTADDR;
break;
case BAS_UBYTE(2u):;
#line 2352 "cpu.bas"
goto L9_L_SETATADDR;
break;
case BAS_UBYTE(3u):;
#line 2352 "cpu.bas"
goto L10_L_GOTNTDATA;
break;
case BAS_UBYTE(4u):;
#line 2352 "cpu.bas"
goto L11_L_GOTATDATA;
break;
case BAS_UBYTE(5u):;
#line 2353 "cpu.bas"
goto L12_L_SETBGLO;
break;
case BAS_UBYTE(6u):;
#line 2353 "cpu.bas"
goto L13_L_SETBGHI;
break;
case BAS_UBYTE(7u):;
#line 2353 "cpu.bas"
goto L14_L_GOTBGLO;
break;
case BAS_UBYTE(8u):;
#line 2353 "cpu.bas"
goto L15_L_GOTBGHI;
break;
case BAS_UBYTE(9u):;
#line 2354 "cpu.bas"
goto L16_L_SETSPLO;
break;
case BAS_UBYTE(10u):;
#line 2354 "cpu.bas"
goto L17_L_SETSPHI;
break;
case BAS_UBYTE(11u):;
#line 2354 "cpu.bas"
goto L18_L_GOTSPLO;
break;
case BAS_UBYTE(12u):;
#line 2354 "cpu.bas"
goto L19_L_GOTSPHI;
break;
}
#line 2355 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2357 "cpu.bas"
L8_L_SETNTADDR: ;
#line 2357 "cpu.bas"
PPU_u.ADDRESSLINE_i = (BAS_INT(24576) | PPUGETVADDR12BIT_f());
#line 2357 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2358 "cpu.bas"
L9_L_SETATADDR: ;
#line 2358 "cpu.bas"
PPU_u.ADDRESSLINE_i = (((BAS_INT(25536) | PPU_u.BASENTA_i) | (BAS_UBYTE(8u) * (PPU_u.YCOARSE_Y / BAS_UBYTE(4u)))) | (PPU_u.XCOARSE_Y / BAS_UBYTE(4u)));
#line 2358 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2359 "cpu.bas"
L10_L_GOTNTDATA: ;
#line 2359 "cpu.bas"
PPU_u.TILENUMBER_i = ((PPU_u.ADDRESSLINE_i & BAS_UBYTE(255u)) * BAS_UBYTE(16u));
#line 2359 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2360 "cpu.bas"
L11_L_GOTATDATA: ;
#line 2360 "cpu.bas"
PPU_u.TILEATTR_Y = ((PPU_u.ADDRESSLINE_i >> ((PPU_u.XCOARSE_Y & BAS_UBYTE(2u)) + (BAS_UBYTE(2u) * (PPU_u.YCOARSE_Y & BAS_UBYTE(2u))))) & BAS_UBYTE(3u));
#line 2360 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2361 "cpu.bas"
L12_L_SETBGLO: ;
#line 2361 "cpu.bas"
PPU_u.ADDRESSLINE_i = (((BAS_INT(16384) | PPU_u.BGADDR_i) | PPU_u.TILENUMBER_i) | PPU_u.FINEY_Y);
#line 2361 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2362 "cpu.bas"
L13_L_SETBGHI: ;
#line 2362 "cpu.bas"
PPU_u.ADDRESSLINE_i = ((((BAS_INT(16384) | PPU_u.BGADDR_i) | PPU_u.TILENUMBER_i) | PPU_u.FINEY_Y) | BAS_UBYTE(8u));
#line 2362 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2363 "cpu.bas"
L18_L_GOTSPLO: ;
#line 2364 "cpu.bas"
L14_L_GOTBGLO: ;
#line 2364 "cpu.bas"
PPU_u.TILEPAT1_Y = (PPU_u.ADDRESSLINE_i & BAS_UBYTE(255u));
#line 2364 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2365 "cpu.bas"
L15_L_GOTBGHI: ;
#line 2365 "cpu.bas"
PPU_u.TILEPAT2_Y = (PPU_u.ADDRESSLINE_i & BAS_UBYTE(255u));
#line 2365 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2370 "cpu.bas"
L17_L_SETSPHI: ;
#line 2370 "cpu.bas"
PPU_u.ADDRESSLINE_i = ((BAS_INT(16384) | PPU_u.TILENUMBER_i) | BAS_UBYTE(8u));
#line 2370 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2372 "cpu.bas"
L16_L_SETSPLO: ;
#line 2374 "cpu.bas"
if((PPU_u.COLUMN_i == BAS_INT(261))) {
#line 2374 "cpu.bas"
if((PPU_u.OAMPHASE_Y & BAS_UBYTE(8u))) {
#line 2374 "cpu.bas"
PPU_u.OAM3LIMIT_Y = BAS_UBYTE(8u);
} else {
#line 2374 "cpu.bas"
PPU_u.OAM3LIMIT_Y = (PPU_u.OAM2POS_Y / BAS_UBYTE(4u));
}
}
#line 2375 "cpu.bas"
PPU_u.OAM2POS_Y = ((PPU_u.COLUMN_i / BAS_UBYTE(8u)) & BAS_UBYTE(7u));
#line 2378 "cpu.bas"
A_Y = OAM2_Y_a[((PPU_u.OAM2POS_Y * BAS_UBYTE(4u)) + BAS_UBYTE(2u))];
#line 2384 "cpu.bas"
A_Y = ((((A_Y & BAS_UBYTE(224u)) | BAS_UBYTE(16u)) | (BAS_UBYTE(4u) * (A_Y & BAS_UBYTE(3u)))) | ((A_Y & BAS_UBYTE(4u)) / BAS_UBYTE(4u)));
#line 2385 "cpu.bas"
OAM3ATTR_Y_a[PPU_u.OAM2POS_Y] = A_Y;
#line 2387 "cpu.bas"
PPU_u.OAMPOSLO_Y = BAS_UBYTE(3u);
#line 2388 "cpu.bas"
OAM3X_Y_a[PPU_u.OAM2POS_Y] = BAS_UBYTE(255u);
#line 2389 "cpu.bas"
if((PPU_u.OAM2POS_Y < PPU_u.OAM3LIMIT_Y)) {
#line 2389 "cpu.bas"
OAM3X_Y_a[PPU_u.OAM2POS_Y] = OAM2_Y_a[((PPU_u.OAM2POS_Y * BAS_UBYTE(4u)) + BAS_UBYTE(3u))];
}
#line 2391 "cpu.bas"
A_Y = (PPU_u.ROW_i - OAM2_Y_a[((PPU_u.OAM2POS_Y * BAS_UBYTE(4u)) + BAS_BYTE(0))]);
#line 2392 "cpu.bas"
C_i = (OAM2_Y_a[((PPU_u.OAM2POS_Y * BAS_UBYTE(4u)) + BAS_UBYTE(1u))] * BAS_UBYTE(16u));
#line 2394 "cpu.bas"
if(((OAM3ATTR_Y_a[PPU_u.OAM2POS_Y] & BAS_UBYTE(128u)) != BAS_BYTE(0))) {
#line 2394 "cpu.bas"
A_Y ^= (PPU_u.SPSIZE_Y + BAS_BYTE(-1));
}
#line 2396 "cpu.bas"
if((PPU_u.SPSIZE_Y == BAS_UBYTE(16u))) {
#line 2396 "cpu.bas"
PPU_u.TILENUMBER_i = ((((A_Y & BAS_UBYTE(7u)) | (BAS_UBYTE(2u) * (A_Y & BAS_UBYTE(8u)))) | (C_i & BAS_INT(4064))) | ((C_i & BAS_UBYTE(16u)) * BAS_INT(256)));
} else {
#line 2398 "cpu.bas"
PPU_u.TILENUMBER_i = (((A_Y & BAS_UBYTE(7u)) | C_i) | PPU_u.SPADDR_i);
}
#line 2400 "cpu.bas"
PPU_u.ADDRESSLINE_i = (BAS_INT(16384) | PPU_u.TILENUMBER_i);
#line 2401 "cpu.bas"
goto L20_L_DONECOLUMNS;
#line 2403 "cpu.bas"
L19_L_GOTSPHI: ;
#line 2403 "cpu.bas"
PPU_u.TILEPAT2_Y = (PPU_u.ADDRESSLINE_i & BAS_UBYTE(255u));
#line 2404 "cpu.bas"
if((PPU_u.OAM2POS_Y < PPU_u.OAM3LIMIT_Y)) {
#line 2405 "cpu.bas"
A_Y = PPU_u.TILEPAT1_Y;
#line 2406 "cpu.bas"
B_Y = PPU_u.TILEPAT2_Y;
#line 2408 "cpu.bas"
if((OAM3ATTR_Y_a[PPU_u.OAM2POS_Y] & BAS_UBYTE(64u))) {
#line 2410 "cpu.bas"
if((BAS_ULONG(sizeof(A_Y)) == BAS_UBYTE(1u))) {
#line 2422 "cpu.bas"
C_I = ((B_Y * BAS_UINT(256u)) + A_Y);
#line 2423 "cpu.bas"
C_I = (((C_I & BAS_UINT(61680u)) / BAS_UBYTE(16u)) | ((C_I & BAS_UINT(3855u)) * BAS_UBYTE(16u)));
#line 2424 "cpu.bas"
C_I = (((C_I & BAS_UINT(52428u)) / BAS_UBYTE(4u)) | ((C_I & BAS_UINT(13107u)) * BAS_UBYTE(4u)));
#line 2425 "cpu.bas"
C_I = (((C_I & BAS_UINT(43690u)) / BAS_UBYTE(2u)) | ((C_I & BAS_UINT(21845u)) * BAS_UBYTE(2u)));
#line 2426 "cpu.bas"
A_Y = (C_I & BAS_UBYTE(255u));
#line 2427 "cpu.bas"
B_Y = (C_I / BAS_UINT(256u));
} else {
#line 2443 "cpu.bas"
A_Y = (((A_Y & BAS_UBYTE(240u)) / BAS_UBYTE(16u)) | ((A_Y & BAS_UBYTE(15u)) * BAS_UBYTE(16u)));
#line 2444 "cpu.bas"
A_Y = (((A_Y & BAS_UBYTE(204u)) / BAS_UBYTE(4u)) | ((A_Y & BAS_UBYTE(51u)) * BAS_UBYTE(4u)));
#line 2445 "cpu.bas"
A_Y = (((A_Y & BAS_UBYTE(170u)) / BAS_UBYTE(2u)) | ((A_Y & BAS_UBYTE(85u)) * BAS_UBYTE(2u)));
#line 2446 "cpu.bas"
B_Y = (((B_Y & BAS_UBYTE(240u)) / BAS_UBYTE(16u)) | ((B_Y & BAS_UBYTE(15u)) * BAS_UBYTE(16u)));
#line 2447 "cpu.bas"
B_Y = (((B_Y & BAS_UBYTE(204u)) / BAS_UBYTE(4u)) | ((B_Y & BAS_UBYTE(51u)) * BAS_UBYTE(4u)));
#line 2448 "cpu.bas"
B_Y = (((B_Y & BAS_UBYTE(170u)) / BAS_UBYTE(2u)) | ((B_Y & BAS_UBYTE(85u)) * BAS_UBYTE(2u)));
}
}
#line 2451 "cpu.bas"
OAM3TILE1_Y_a[PPU_u.OAM2POS_Y] = A_Y;
#line 2452 "cpu.bas"
OAM3TILE2_Y_a[PPU_u.OAM2POS_Y] = B_Y;
}
#line 2457 "cpu.bas"
L20_L_DONECOLUMNS: ;
#line 2459 "cpu.bas"
switch((CATEGORY_i & BAS_UBYTE(7u))) {
case BAS_UBYTE(1u):;
#line 2459 "cpu.bas"
goto L21_L_GENSYNC;
break;
case BAS_UBYTE(2u):;
#line 2459 "cpu.bas"
goto L22_L_GENBLACK;
break;
case BAS_UBYTE(3u):;
#line 2459 "cpu.bas"
goto L23_L_GENBURST;
break;
case BAS_UBYTE(4u):;
#line 2459 "cpu.bas"
goto L24_L_GENPULSE;
break;
case BAS_UBYTE(5u):;
#line 2459 "cpu.bas"
goto L25_L_GENBORDER;
break;
case BAS_UBYTE(6u):;
#line 2459 "cpu.bas"
goto L26_L_GENGAMEACTIVE;
break;
case BAS_UBYTE(7u):;
#line 2459 "cpu.bas"
goto L27_L_GENGAMEPASSIVE;
break;
}
#line 2460 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
#line 2462 "cpu.bas"
L21_L_GENSYNC: ;
#line 2462 "cpu.bas"
PPU_u.CURRENTSIGNALMODE_l = BAS_BYTE(-1);
#line 2462 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
#line 2463 "cpu.bas"
L24_L_GENPULSE: ;
#line 2463 "cpu.bas"
PPU_u.CURRENTSIGNALMODE_l = ((PRAM_Y_a[BAS_BYTE(0)] & BAS_UBYTE(48u)) | PPU_u.EMPHASISPHASES_l);
#line 2463 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
#line 2464 "cpu.bas"
L23_L_GENBURST: ;
#line 2464 "cpu.bas"
PPU_u.CURRENTSIGNALMODE_l = BAS_BYTE(-3);
#line 2464 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
#line 2465 "cpu.bas"
L22_L_GENBLACK: ;
#line 2465 "cpu.bas"
PPU_u.CURRENTSIGNALMODE_l = BAS_BYTE(-2);
#line 2465 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
#line 2468 "cpu.bas"
L25_L_GENBORDER: ;
#line 2468 "cpu.bas"
A_Y = PRAM_Y_a[BAS_BYTE(0)];
#line 2469 "cpu.bas"
if(PPUTESTVADDRIS3FXX_f()) {
#line 2469 "cpu.bas"
A_Y = PRAM_Y_a[PPU_u.XCOARSE_Y];
}
#line 2470 "cpu.bas"
PPU_u.CURRENTSIGNALMODE_l = ((A_Y & PPU_u.GRAYSCALE_Y) | PPU_u.EMPHASISPHASES_l);
#line 2471 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
#line 2474 "cpu.bas"
L27_L_GENGAMEPASSIVE: ;
#line 2474 "cpu.bas"
PPU_u.PIXELQUEUE_U = (PPU_u.PIXELQUEUE_U / 64u);
#line 2475 "cpu.bas"
goto L29_L_SENDPIXEL;
#line 2478 "cpu.bas"
L26_L_GENGAMEACTIVE: ;
#line 2480 "cpu.bas"
PIX_Y = BAS_BYTE(0);
#line 2482 "cpu.bas"
if((PPU_u.SHOWBG_Y && ((PPU_u.SHOWBG8_Y != BAS_BYTE(0)) || (PPU_u.COLUMN_i > BAS_UBYTE(8u))))) {
#line 2488 "cpu.bas"
if(((PPU_u.SHIFTPAT1_i | PPU_u.SHIFTPAT2_i) & PPU_u.FINEXSDIV_i)) {
#line 2489 "cpu.bas"
if((PPU_u.SHIFTPAT1_i & PPU_u.FINEXSDIV_i)) {
#line 2489 "cpu.bas"
PIX_Y |= BAS_UBYTE(1u);
}
#line 2490 "cpu.bas"
if((PPU_u.SHIFTPAT2_i & PPU_u.FINEXSDIV_i)) {
#line 2490 "cpu.bas"
PIX_Y |= BAS_UBYTE(2u);
}
#line 2491 "cpu.bas"
if((PPU_u.SHIFTATTR1_i & PPU_u.FINEXSDIV_i)) {
#line 2491 "cpu.bas"
PIX_Y |= BAS_UBYTE(4u);
}
#line 2492 "cpu.bas"
if((PPU_u.SHIFTATTR2_i & PPU_u.FINEXSDIV_i)) {
#line 2492 "cpu.bas"
PIX_Y |= BAS_UBYTE(8u);
}
}
}
#line 2497 "cpu.bas"
if((PPU_u.COLUMN_i < BAS_INT(256))) {
#line 2497 "cpu.bas"
SHOWSP_y = (PPU_u.SHOWSP_Y & (((PPU_u.SHOWSP8_Y != BAS_BYTE(0)) ? -1 : 0) | ((PPU_u.COLUMN_i > BAS_UBYTE(8u)) ? -1 : 0)));
#line 2500 "cpu.bas"
fend3_i = ((PPU_u.OAM3LIMIT_Y + BAS_BYTE(-1)) + BAS_UBYTE(1u)); for(SPRITENO_i = BAS_BYTE(0);SPRITENO_i < fend3_i;SPRITENO_i += BAS_BYTE(1)) {
#line 2501 "cpu.bas"
if((OAM3X_Y_a[SPRITENO_i] != BAS_BYTE(0))) {
#line 2501 "cpu.bas"
OAM3X_Y_a[SPRITENO_i] = ((OAM3X_Y_a[SPRITENO_i] - BAS_UBYTE(1u)) & BAS_UBYTE(255u));
} else {
#line 2503 "cpu.bas"
A_Y = OAM3TILE1_Y_a[SPRITENO_i];
#line 2504 "cpu.bas"
B_Y = OAM3TILE2_Y_a[SPRITENO_i];
#line 2505 "cpu.bas"
BOTH_Y = (A_Y | B_Y);
#line 2507 "cpu.bas"
if((BOTH_Y != BAS_BYTE(0))) {
#line 2509 "cpu.bas"
if(((SHOWSP_y != BAS_BYTE(0)) && ((BOTH_Y & BAS_UBYTE(128u)) != BAS_BYTE(0)))) {
#line 2510 "cpu.bas"
C_i = OAM3ATTR_Y_a[SPRITENO_i];
#line 2512 "cpu.bas"
if(((PIX_Y & BAS_UBYTE(3u)) != BAS_BYTE(0))) {
#line 2513 "cpu.bas"
if((C_i & BAS_UBYTE(1u))) {
#line 2513 "cpu.bas"
PPU_u.SP0HIT_Y = BAS_UBYTE(64u);
}
#line 2515 "cpu.bas"
if(((C_i & BAS_UBYTE(32u)) == BAS_BYTE(0))) {
#line 2515 "cpu.bas"
goto L30_L_RENDERSPRITEPIXEL;
}
} else {
#line 2519 "cpu.bas"
L30_L_RENDERSPRITEPIXEL: ;
#line 2519 "cpu.bas"
PIX_Y = (C_i & BAS_UBYTE(28u));
#line 2520 "cpu.bas"
if((A_Y & BAS_UBYTE(128u))) {
#line 2520 "cpu.bas"
PIX_Y |= BAS_UBYTE(1u);
}
#line 2521 "cpu.bas"
if((B_Y & BAS_UBYTE(128u))) {
#line 2521 "cpu.bas"
PIX_Y |= BAS_UBYTE(2u);
}
}
#line 2524 "cpu.bas"
SHOWSP_y = BAS_BYTE(0);
}
#line 2526 "cpu.bas"
OAM3TILE1_Y_a[SPRITENO_i] = ((A_Y * BAS_UBYTE(2u)) & BAS_UBYTE(255u));
#line 2527 "cpu.bas"
OAM3TILE2_Y_a[SPRITENO_i] = ((B_Y * BAS_UBYTE(2u)) & BAS_UBYTE(255u));
}
}
}
}
#line 2532 "cpu.bas"
PPU_u.PIXELQUEUE_U = ((PPU_u.PIXELQUEUE_U / 64u) | (PRAM_Y_a[(PIX_Y & BAS_UBYTE(31u))] * 262144u));
#line 2533 "cpu.bas"
if((PPU_u.COLUMN_i < BAS_UBYTE(4u))) {
#line 2533 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
}
#line 2536 "cpu.bas"
L29_L_SENDPIXEL: ;
#line 2546 "cpu.bas"
PPU_u.CURRENTSIGNALMODE_l = ((PPU_u.PIXELQUEUE_U & PPU_u.GRAYSCALE_Y) | PPU_u.EMPHASISPHASES_l);
#line 2547 "cpu.bas"
if(BAS_INT(0)) {
#line 2547 "cpu.bas"
B_StmtPSET(BAS_UBYTE(0u), PPU_u.COLUMN_i, PPU_u.ROW_i, (263172 * (PPU_u.CURRENTSIGNALMODE_l & BAS_UBYTE(63u))));
}
#line 2548 "cpu.bas"
goto L28_L_DONEGENSIGNAL;
#line 2551 "cpu.bas"
L28_L_DONEGENSIGNAL: ;
#line 2554 "cpu.bas"
if(BAS_INT(0)) {
#line 2554 "cpu.bas"
switch(PPU_u.CURRENTSIGNALMODE_l) {
case BAS_BYTE(-1):;
#line 2555 "cpu.bas"
RGB_U = 16711680;
break;
case BAS_BYTE(-2):;
#line 2556 "cpu.bas"
RGB_U = BAS_UBYTE(96u);
break;
case BAS_BYTE(-3):;
#line 2557 "cpu.bas"
RGB_U = 16728064;
break;
default:;
#line 2558 "cpu.bas"
RGB_U = (197379 * (PPU_u.CURRENTSIGNALMODE_l & BAS_UBYTE(63u)));
}
#line 2561 "cpu.bas"
if(((PPU_u.ROW_i % BAS_UBYTE(10u)) == BAS_BYTE(0))) {
#line 2561 "cpu.bas"
RGB_U += 32768u;
}
#line 2562 "cpu.bas"
for(A_Y = BAS_UBYTE(1u);A_Y <= BAS_UBYTE(2u);A_Y += BAS_BYTE(1)) {
#line 2563 "cpu.bas"
for(B_Y = BAS_UBYTE(1u);B_Y <= BAS_UBYTE(2u);B_Y += BAS_BYTE(1)) {
#line 2564 "cpu.bas"
B_StmtPSET(BAS_UBYTE(0u), (((PPU_u.COLUMN_i * BAS_UBYTE(2u)) + A_Y) + BAS_BYTE(-1)), (((PPU_u.ROW_i * BAS_UBYTE(2u)) + B_Y) + BAS_BYTE(-1)), RGB_U);
}
}
} else {
#line 2554 "cpu.bas"
if(BAS_INT(-1)) {
#line 2567 "cpu.bas"
if((SKIPCOUNTER_i == BAS_BYTE(0))) {
#line 2567 "cpu.bas"
PPURENDER_f(PPU_u.CURRENTSIGNALMODE_l);
}
}
}
#line 2578 "cpu.bas"
if((CATEGORY_i & BAS_UBYTE(8u))) {
#line 2578 "cpu.bas"
PPUINCRVADDRHORIZ_f();
}
#line 2579 "cpu.bas"
if((CATEGORY_i & BAS_UBYTE(16u))) {
#line 2579 "cpu.bas"
PPUINCRVADDRVERT_f();
}
#line 2580 "cpu.bas"
if((CATEGORY_i & BAS_UBYTE(32u))) {
#line 2580 "cpu.bas"
PPUCOPYHORIZ_f();
}
#line 2581 "cpu.bas"
if((CATEGORY_i & BAS_UBYTE(64u))) {
#line 2581 "cpu.bas"
PPUCOPYVERT_f();
}
#line 2582 "cpu.bas"
if((CATEGORY_i & BAS_UBYTE(128u))) {
#line 2582 "cpu.bas"
PPUSHIFT_f();
}
#line 2584 "cpu.bas"
if((PPU_u.INVBLANK_y == BAS_UBYTE(1u))) {
#line 2584 "cpu.bas"
PPU_u.INVBLANK_y = BAS_UBYTE(3u);
}
#line 2585 "cpu.bas"
if((PPU_u.INVBLANK_y == BAS_BYTE(-1))) {
#line 2585 "cpu.bas"
PPU_u.INVBLANK_y = BAS_BYTE(0);
}
#line 2587 "cpu.bas"
selv0_i = PPU_u.COLUMN_i; if(selv0_i == BAS_UBYTE(1u)) {
#line 2588 "cpu.bas"
while(BAS_ULONG((
#line 2588 "cpu.bas"
B_FuncINKEY_S()).size())) {
}
#line 2590 "cpu.bas"
if((PPU_u.ROW_i == BAS_UBYTE(241u))) {
#line 2593 "cpu.bas"
PPU_u.INVBLANK_y = BAS_UBYTE(1u);
#line 2597 "cpu.bas"
if(BAS_INT(-1)) {
#line 2597 "cpu.bas"
CURTIMER_z = 
#line 2598 "cpu.bas"
B_FuncTIMER();
#line 2598 "cpu.bas"
if((PREVTIMER_z == BAS_BYTE(0))) {
#line 2598 "cpu.bas"
PREVTIMER_z = CURTIMER_z;
}
#line 2599 "cpu.bas"
A_Y = (BAS_UBYTE(1u) + BAS_UBYTE(15u));
#line 2600 "cpu.bas"
TIMINGSUM_z -= FRAMETIMINGS_z_a[FRAMECOUNTER_Y];
#line 2601 "cpu.bas"
FRAMETIMINGS_z_a[FRAMECOUNTER_Y] = (CURTIMER_z - PREVTIMER_z);
#line 2602 "cpu.bas"
TIMINGSUM_z += FRAMETIMINGS_z_a[FRAMECOUNTER_Y];
#line 2603 "cpu.bas"
FRAMECOUNTER_Y = ((FRAMECOUNTER_Y + BAS_UBYTE(1u)) % A_Y);
#line 2609 "cpu.bas"
RATE_d = (A_Y / (BAS_DBL)TIMINGSUM_z);
#line 2610 "cpu.bas"
TARGETRATE_d = (60.098813897442290966 * TURBOFACTOR_z);
#line 2613 "cpu.bas"
if((((RATE_d < TARGETRATE_d) || (SKIPTREND_z < BAS_UBYTE(1u))) && (SKIPTREND_z < BAS_INT(500)))) {
#line 2614 "cpu.bas"
I_z = BAS_UBYTE(1u);
#line 2616 "cpu.bas"
if((RATE_d < (TARGETRATE_d / (BAS_DBL)BAS_UBYTE(2u)))) {
#line 2616 "cpu.bas"
if((SKIPTREND_z < BAS_UBYTE(100u))) {
#line 2616 "cpu.bas"
I_z = BAS_UBYTE(1u);
} else {
#line 2616 "cpu.bas"
if((SKIPTREND_z < BAS_INT(300))) {
#line 2616 "cpu.bas"
I_z = 0.5f;
} else {
#line 2617 "cpu.bas"
I_z = 0.30000001192092895508f;
}
}
} else {
#line 2618 "cpu.bas"
I_z = 0.10000000149011611938f;
}
#line 2620 "cpu.bas"
SKIPTREND_z += I_z;
#line 2621 "cpu.bas"
if(((SKIPTREND_z >= BAS_UBYTE(5u)) && (TURBOFACTOR_z > 0.10000000149011611938f))) {
#line 2621 "cpu.bas"
TURBOFACTOR_z *= 0.89999997615814208984f;
}
} else {
#line 2623 "cpu.bas"
SKIPTREND_z -= 0.10000000149011611938f;
#line 2624 "cpu.bas"
TURBOFACTOR_z *= 1.1000000238418579102f;
}
#line 2626 "cpu.bas"
if((((RATE_d >= (TARGETRATE_d * 0.75f)) && (SKIPTREND_z < BAS_UBYTE(8u))) && (TURBOFACTOR_z < BAS_UBYTE(1u)))) {
#line 2626 "cpu.bas"
TURBOFACTOR_z *= 1.1000000238418579102f;
}
#line 2627 "cpu.bas"
if((TURBOFACTOR_z > BAS_UBYTE(1u))) {
#line 2627 "cpu.bas"
TURBOFACTOR_z = BAS_UBYTE(1u);
}
#line 2633 "cpu.bas"
PREVTIMER_z = CURTIMER_z;
} else {
#line 2635 "cpu.bas"
SKIPTREND_z = BAS_BYTE(0);
}
#line 2637 "cpu.bas"
if((SKIPCOUNTER_i <= BAS_BYTE(0))) {
#line 2637 "cpu.bas"
SKIPCOUNTER_i = SKIPTREND_z;
#line 2637 "cpu.bas"
B_Stmtqb64DISPLAY();
}
#line 2638 "cpu.bas"
SKIPCOUNTER_i += BAS_BYTE(-1);
}
#line 2641 "cpu.bas"
if((PPU_u.ROW_i == BAS_INT(261))) {
#line 2641 "cpu.bas"
PPU_u.INVBLANK_y = BAS_BYTE(-1);
#line 2641 "cpu.bas"
PPU_u.SPOVERFLOW_Y = BAS_BYTE(0);
#line 2641 "cpu.bas"
PPU_u.SP0HIT_Y = BAS_BYTE(0);
}
#line 2643 "cpu.bas"
PPU_u.COLUMN_i = BAS_UBYTE(2u);
} else if(selv0_i < BAS_INT(340)) {
#line 2645 "cpu.bas"
PPU_u.COLUMN_i += BAS_UBYTE(1u);
} else {
#line 2647 "cpu.bas"
PPU_u.COLUMN_i = BAS_BYTE(0);
#line 2649 "cpu.bas"
if((PPU_u.ROW_i < BAS_INT(261))) {
#line 2649 "cpu.bas"
PPU_u.ROW_i += BAS_UBYTE(1u);
} else {
#line 2652 "cpu.bas"
PPU_u.ROW_i = BAS_BYTE(0);
#line 2652 "cpu.bas"
if((((PPU_u.FRAMECOUNT_U & BAS_UBYTE(1u)) == BAS_UBYTE(1u)) && (PPU_u.SHOW_y != BAS_BYTE(0)))) {
#line 2652 "cpu.bas"
PPU_u.COLUMN_i = BAS_UBYTE(1u);
}
#line 2653 "cpu.bas"
PPU_u.CYCLECOUNT_U = (PPU_u.CYCLECOUNT_U % BAS_INT(480));
#line 2656 "cpu.bas"
if(BAS_INT(-1)) {
#line 2657 "cpu.bas"
for(A_Y = BAS_BYTE(0);A_Y < BAS_INT(4);A_Y += BAS_BYTE(1)) {
#line 2657 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "NTA  " << A_Y << ' ' << PrintCRLFtag{}; 
#line 2659 "cpu.bas"
for(B_Y = BAS_BYTE(0);B_Y < BAS_INT(30);B_Y += BAS_BYTE(1)) {
#line 2659 "cpu.bas"
for(C_i = BAS_BYTE(0);C_i < BAS_INT(32);C_i += BAS_BYTE(1)) {
#line 2659 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << 
#line 2659 "cpu.bas"
B_FuncCHR_S(NRAM_Y_a[(((A_Y * BAS_UINT(1024u)) + (B_Y * BAS_UBYTE(32u))) + C_i)]); 
}
#line 2660 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << PrintCRLFtag{}; 
}
}
#line 2663 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "PRAM:" << PrintCRLFtag{}; 
#line 2663 "cpu.bas"
for(C_i = BAS_BYTE(0);C_i < BAS_INT(32);C_i += BAS_BYTE(1)) {
#line 2663 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << 
#line 2663 "cpu.bas"
B_FuncCHR_S(PRAM_Y_a[C_i]); 
}
#line 2663 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << PrintCRLFtag{}; 
#line 2664 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "OAM:" << PrintCRLFtag{}; 
#line 2664 "cpu.bas"
for(C_i = BAS_BYTE(0);C_i < BAS_INT(256);C_i += BAS_BYTE(1)) {
#line 2664 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << 
#line 2664 "cpu.bas"
B_FuncCHR_S(OAM_Y_a[C_i]); 
}
#line 2664 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << PrintCRLFtag{}; 
#line 2665 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "OAM2:" << PrintCRLFtag{}; 
#line 2665 "cpu.bas"
for(C_i = BAS_BYTE(0);C_i < BAS_INT(32);C_i += BAS_BYTE(1)) {
#line 2665 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << 
#line 2665 "cpu.bas"
B_FuncCHR_S(OAM2_Y_a[C_i]); 
}
#line 2665 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << PrintCRLFtag{}; 
}
#line 2667 "cpu.bas"
PPU_u.FRAMECOUNT_U += BAS_UBYTE(1u);
}
#line 2670 "cpu.bas"
PPUSETROWCLASS_f();
} 
#line 2673 "cpu.bas"
CPU_u.NMI_i = ((CPU_u.NMI_i & BAS_UBYTE(6u)) | (-((((PPU_u.INVBLANK_y == BAS_UBYTE(3u)) ? -1 : 0) | ((PPU_u.INVBLANK_y == BAS_UBYTE(1u)) ? -1 : 0)) & ((PPU_u.NMIENABLED_Y != BAS_BYTE(0)) ? -1 : 0))));
#line 2675 "cpu.bas"
PPU_u.CYCLECOUNT_U += BAS_UBYTE(1u);
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB WB */
#line 885 "cpu.bas"
void WB_f(BAS_UBYTE T_Y)
{
B_ERR_FRAME_SUB_BEGIN();
#line 886 "cpu.bas"
IOBYTE_Y = (T_Y & BAS_UBYTE(255u));
#line 887 "cpu.bas"
MEMACCESS_f(BAS_UBYTE(1u));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUGETVADDR */
#line 2034 "cpu.bas"
BAS_INT PPUGETVADDR_f()
{
BAS_INT FunctionReturn_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2035 "cpu.bas"
FunctionReturn_i = (((PPU_u.XCOARSE_Y | PPU_u.YCOARSE32_i) | PPU_u.BASENTA_i) | ((PPU_u.FINEY_Y & BAS_UBYTE(3u)) * BAS_INT(4096)));
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUWRITE */
#line 1050 "cpu.bas"
void APUWRITE_f()
{
#line 1051 "cpu.bas"
BAS_UBYTE N_Y { };
#line 1051 "cpu.bas"
BAS_UBYTE CHNO_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1052 "cpu.bas"
CHNO_Y = ((ADDR_i & BAS_UBYTE(31u)) / BAS_UBYTE(4u));
#line 1054 "cpu.bas"
switch((ADDR_i & BAS_UBYTE(31u))) {
case BAS_BYTE(0):;
case BAS_UBYTE(4u):;
case BAS_UBYTE(12u):;
#line 1057 "cpu.bas"
switch(((IOBYTE_Y / BAS_UBYTE(64u)) & BAS_UBYTE(3u))) {
case BAS_BYTE(0):;
#line 1057 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].DUTYCYCLE_Y = BAS_UBYTE(4u);
break;
case BAS_UBYTE(1u):;
#line 1058 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].DUTYCYCLE_Y = BAS_UBYTE(12u);
break;
case BAS_UBYTE(2u):;
#line 1059 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].DUTYCYCLE_Y = BAS_UBYTE(60u);
break;
case BAS_UBYTE(3u):;
#line 1060 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].DUTYCYCLE_Y = BAS_UBYTE(243u);
break;
}
#line 1062 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].ENVDECAYLOOPENABLE_Y = ((IOBYTE_Y / BAS_UBYTE(32u)) & BAS_UBYTE(1u));
#line 1063 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTERDISABLE_Y = ((IOBYTE_Y / BAS_UBYTE(32u)) & BAS_UBYTE(1u));
#line 1064 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].ENVDECAYDISABLE_Y = ((IOBYTE_Y / BAS_UBYTE(16u)) & BAS_UBYTE(1u));
#line 1065 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].ENVDECAYRATE_Y = (IOBYTE_Y & BAS_UBYTE(15u));
#line 1066 "cpu.bas"
if(APUCHANNELS_u_a[CHNO_Y].ENVDECAYDISABLE_Y) {
#line 1067 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].ENVELOPE_Y = (IOBYTE_Y & BAS_UBYTE(15u));
}
break;
case BAS_UBYTE(1u):;
case BAS_UBYTE(5u):;
#line 1072 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].SWEEPENABLE_Y = ((IOBYTE_Y / BAS_UBYTE(128u)) & BAS_UBYTE(1u));
#line 1073 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].SWEEPRATE_Y = ((IOBYTE_Y / BAS_UBYTE(16u)) & BAS_UBYTE(7u));
#line 1074 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].SWEEPDECREASE_Y = ((IOBYTE_Y / BAS_UBYTE(8u)) & BAS_UBYTE(1u));
#line 1075 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].SWEEPSHIFT_Y = (IOBYTE_Y & BAS_UBYTE(7u));
break;
case BAS_UBYTE(2u):;
case BAS_UBYTE(6u):;
case BAS_UBYTE(10u):;
#line 1078 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].WAVELENGTH_i = ((APUCHANNELS_u_a[CHNO_Y].WAVELENGTH_i & BAS_INT(1792)) | IOBYTE_Y);
break;
case BAS_UBYTE(3u):;
case BAS_UBYTE(7u):;
case BAS_UBYTE(15u):;
#line 1081 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].WAVELENGTH_i = ((APUCHANNELS_u_a[CHNO_Y].WAVELENGTH_i & BAS_UBYTE(255u)) | ((IOBYTE_Y & BAS_UBYTE(7u)) * BAS_INT(256)));
#line 1082 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].ENVDELAY_Y = APUCHANNELS_u_a[CHNO_Y].ENVDECAYRATE_Y;
#line 1083 "cpu.bas"
if((APUCHANNELS_u_a[CHNO_Y].ENVDECAYDISABLE_Y == BAS_BYTE(0))) {
#line 1083 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].ENVELOPE_Y = BAS_UBYTE(15u);
}
#line 1084 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].PHASE_Y = BAS_BYTE(0);
#line 1085 "cpu.bas"
goto L31_L_LENGTHCOUNTERWRITTEN;
break;
case BAS_UBYTE(8u):;
#line 1087 "cpu.bas"
CHNO_Y = BAS_UBYTE(2u);
#line 1088 "cpu.bas"
APU_u.LINEARCOUNTERINIT_Y = (IOBYTE_Y & BAS_UBYTE(127u));
#line 1090 "cpu.bas"
if((APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTERDISABLE_Y != BAS_BYTE(0))) {
#line 1090 "cpu.bas"
APU_u.LINEARCOUNTER_Y = APU_u.LINEARCOUNTERINIT_Y;
}
#line 1092 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTERDISABLE_Y = ((IOBYTE_Y / BAS_UBYTE(128u)) & BAS_UBYTE(1u));
break;
case BAS_UBYTE(11u):;
#line 1097 "cpu.bas"
CHNO_Y = BAS_UBYTE(2u);
#line 1098 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].WAVELENGTH_i = ((APUCHANNELS_u_a[CHNO_Y].WAVELENGTH_i & BAS_UBYTE(255u)) | ((IOBYTE_Y & BAS_UBYTE(7u)) * BAS_INT(256)));
#line 1099 "cpu.bas"
APU_u.LINEARCOUNTER_Y = APU_u.LINEARCOUNTERINIT_Y;
#line 1101 "cpu.bas"
L31_L_LENGTHCOUNTERWRITTEN: ;
#line 1101 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTERINIT_Y = ((IOBYTE_Y / BAS_UBYTE(8u)) & BAS_UBYTE(31u));
#line 1104 "cpu.bas"
if(((APU_u.CHANNELSENABLED_Y & (BAS_UBYTE(1u) << CHNO_Y)) != BAS_BYTE(0))) {
#line 1104 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTER_Y = APULENGTHS_i_a[APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTERINIT_Y];
}
break;
case BAS_UBYTE(14u):;
#line 1110 "cpu.bas"
CHNO_Y = BAS_UBYTE(3u);
#line 1111 "cpu.bas"
APU_u.NOISETYPE_Y = ((IOBYTE_Y / BAS_UBYTE(128u)) & BAS_UBYTE(1u));
#line 1112 "cpu.bas"
APU_u.NOISEFREQ_Y = (IOBYTE_Y & BAS_UBYTE(15u));
break;
case BAS_UBYTE(16u):;
#line 1115 "cpu.bas"
CHNO_Y = BAS_UBYTE(4u);
#line 1116 "cpu.bas"
APU_u.IRQENABLE_Y = ((IOBYTE_Y / BAS_UBYTE(128u)) & BAS_UBYTE(1u));
#line 1117 "cpu.bas"
APU_u.LOOPENABLED_Y = ((IOBYTE_Y / BAS_UBYTE(64u)) & BAS_UBYTE(1u));
#line 1118 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].WAVELENGTH_i = APUPERIODSDMC_i_a[(IOBYTE_Y & BAS_UBYTE(15u))];
break;
case BAS_UBYTE(17u):;
#line 1122 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].LEVEL_Y = (IOBYTE_Y & BAS_UBYTE(127u));
break;
case BAS_UBYTE(18u):;
#line 1125 "cpu.bas"
CHNO_Y = BAS_UBYTE(4u);
#line 1126 "cpu.bas"
APU_u.ADDRESS_i = ((IOBYTE_Y * BAS_UBYTE(64u)) | BAS_UINT(49152u));
#line 1127 "cpu.bas"
APU_u.ADDRESSINIT_i = APU_u.ADDRESS_i;
break;
case BAS_UBYTE(19u):;
#line 1130 "cpu.bas"
CHNO_Y = BAS_UBYTE(4u);
#line 1131 "cpu.bas"
APU_u.PCMLENGTH_i = ((IOBYTE_Y * BAS_UBYTE(16u)) + BAS_UBYTE(1u));
#line 1132 "cpu.bas"
if((APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTER_Y == BAS_BYTE(0))) {
#line 1132 "cpu.bas"
APUCHANNELS_u_a[CHNO_Y].LENGTHCOUNTER_Y = APU_u.PCMLENGTH_i;
}
break;
case BAS_UBYTE(21u):;
#line 1135 "cpu.bas"
APU_u.CHANNELSENABLED_Y = (IOBYTE_Y & BAS_UBYTE(31u));
#line 1138 "cpu.bas"
for(N_Y = BAS_BYTE(0);N_Y < BAS_INT(5);N_Y += BAS_BYTE(1)) {
#line 1139 "cpu.bas"
if(((APU_u.CHANNELSENABLED_Y & (BAS_UBYTE(1u) << N_Y)) == BAS_BYTE(0))) {
#line 1139 "cpu.bas"
APUCHANNELS_u_a[N_Y].LENGTHCOUNTER_Y = BAS_BYTE(0);
} else {
#line 1139 "cpu.bas"
if(((N_Y == BAS_UBYTE(4u)) && (APUCHANNELS_u_a[N_Y].LENGTHCOUNTER_Y == BAS_BYTE(0)))) {
#line 1141 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].LENGTHCOUNTER_Y = APU_u.PCMLENGTH_i;
#line 1142 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].PHASE_Y = BAS_BYTE(0);
#line 1143 "cpu.bas"
APU_u.ADDRESS_i = APU_u.ADDRESSINIT_i;
}
}
}
#line 1146 "cpu.bas"
CPU_u.IRQ_i &= BAS_UBYTE(127u);
break;
case BAS_UBYTE(23u):;
#line 1149 "cpu.bas"
APU_u.IRQDISABLE_Y = ((IOBYTE_Y / BAS_UBYTE(64u)) & BAS_UBYTE(1u));
#line 1150 "cpu.bas"
APU_u.FRAMEDELAY_i &= BAS_UBYTE(1u);
#line 1156 "cpu.bas"
APU_u.FRAME_Y = BAS_UBYTE(6u);
#line 1157 "cpu.bas"
if((APU_u.IRQDISABLE_Y != BAS_BYTE(0))) {
#line 1157 "cpu.bas"
CPU_u.IRQ_i &= BAS_UBYTE(191u);
}
#line 1158 "cpu.bas"
if(((IOBYTE_Y & BAS_UBYTE(128u)) == BAS_BYTE(0))) {
#line 1159 "cpu.bas"
APU_u.FRAMEDELAY_i = ((APU_u.FRAMEDELAY_i + BAS_INT(7458)) + BAS_UBYTE(1u));
#line 1159 "cpu.bas"
APU_u.FRAME_Y = BAS_BYTE(0);
}
break;
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUSHIFT */
#line 2081 "cpu.bas"
void PPUSHIFT_f()
{
#line 2093 "cpu.bas"
BAS_INT C_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2094 "cpu.bas"
C_i = ((PPU_u.SHIFTPAT1_i & BAS_INT(16383)) * BAS_UBYTE(2u));
#line 2094 "cpu.bas"
if((PPU_u.SHIFTPAT1_i & BAS_INT(16384))) {
#line 2094 "cpu.bas"
C_i |= BAS_UINT(32768u);
}
#line 2095 "cpu.bas"
PPU_u.SHIFTPAT1_i = C_i;
#line 2096 "cpu.bas"
C_i = ((PPU_u.SHIFTPAT2_i & BAS_INT(16383)) * BAS_UBYTE(2u));
#line 2096 "cpu.bas"
if((PPU_u.SHIFTPAT2_i & BAS_INT(16384))) {
#line 2096 "cpu.bas"
C_i |= BAS_UINT(32768u);
}
#line 2097 "cpu.bas"
PPU_u.SHIFTPAT2_i = C_i;
#line 2098 "cpu.bas"
C_i = ((PPU_u.SHIFTATTR1_i & BAS_INT(16383)) * BAS_UBYTE(2u));
#line 2098 "cpu.bas"
if((PPU_u.SHIFTATTR1_i & BAS_INT(16384))) {
#line 2098 "cpu.bas"
C_i |= BAS_UINT(32768u);
}
#line 2099 "cpu.bas"
PPU_u.SHIFTATTR1_i = C_i;
#line 2100 "cpu.bas"
C_i = ((PPU_u.SHIFTATTR2_i & BAS_INT(16383)) * BAS_UBYTE(2u));
#line 2100 "cpu.bas"
if((PPU_u.SHIFTATTR2_i & BAS_INT(16384))) {
#line 2100 "cpu.bas"
C_i |= BAS_UINT(32768u);
}
#line 2101 "cpu.bas"
PPU_u.SHIFTATTR2_i = C_i;
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB RB */
#line 891 "cpu.bas"
BAS_UBYTE RB_f()
{
BAS_UBYTE FunctionReturn_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 892 "cpu.bas"
MEMACCESS_f(BAS_BYTE(0));
#line 893 "cpu.bas"
FunctionReturn_Y = IOBYTE_Y;
    return FunctionReturn_Y;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUCOPYHORIZ */
#line 2069 "cpu.bas"
void PPUCOPYHORIZ_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2071 "cpu.bas"
PPU_u.XCOARSE_Y = PPU_u.XCOARSES_Y;
#line 2072 "cpu.bas"
PPU_u.BASENTA_i = ((PPU_u.BASENTA_i & BAS_INT(2048)) | (PPU_u.BASENTAS_i & BAS_INT(1024)));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUINCRVADDRHORIZ */
#line 2044 "cpu.bas"
void PPUINCRVADDRHORIZ_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2045 "cpu.bas"
PPU_u.XCOARSE_Y = ((PPU_u.XCOARSE_Y + BAS_UBYTE(1u)) & BAS_UBYTE(31u));
#line 2045 "cpu.bas"
if((PPU_u.XCOARSE_Y != BAS_BYTE(0))) {
#line 2046 "cpu.bas"
goto subfunc_exit;
}
#line 2046 "cpu.bas"
PPU_u.BASENTA_i ^= BAS_INT(1024);
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUINCROAMPOSHI */
#line 2006 "cpu.bas"
void PPUINCROAMPOSHI_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2007 "cpu.bas"
PPU_u.OAMPOSHI_Y = ((PPU_u.OAMPOSHI_Y + BAS_UBYTE(4u)) & BAS_UBYTE(252u));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB FLAGS */
#line 919 "cpu.bas"
BAS_INT FLAGS_f()
{
BAS_INT FunctionReturn_i { };
#line 920 "cpu.bas"
BAS_UBYTE V_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 921 "cpu.bas"
V_Y = ((CPU_u.V_Y & BAS_UBYTE(64u)) | CPU_u.I_Y);
#line 922 "cpu.bas"
if(CPU_u.C_i) {
#line 922 "cpu.bas"
V_Y |= BAS_UBYTE(1u);
}
#line 923 "cpu.bas"
if(CPU_u.D_y) {
#line 923 "cpu.bas"
V_Y |= BAS_UBYTE(8u);
}
#line 924 "cpu.bas"
if((CPU_u.NZ_i >= BAS_UBYTE(128u))) {
#line 924 "cpu.bas"
V_Y |= BAS_UBYTE(128u);
}
#line 925 "cpu.bas"
if(((CPU_u.NZ_i & BAS_UBYTE(255u)) == BAS_BYTE(0))) {
#line 925 "cpu.bas"
V_Y |= BAS_UBYTE(2u);
}
#line 926 "cpu.bas"
FunctionReturn_i = V_Y;
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUSETROWCLASS */
#line 2021 "cpu.bas"
void PPUSETROWCLASS_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2023 "cpu.bas"
switch(PPU_u.ROW_i) {
case BAS_BYTE(0) ... BAS_UBYTE(239u):;
#line 2023 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(0);
#line 2023 "cpu.bas"
if((PPU_u.SHOW_y == BAS_BYTE(0))) {
#line 2023 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(682);
}
break;
case BAS_INT(261):;
#line 2024 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(341);
#line 2024 "cpu.bas"
if((PPU_u.SHOW_y == BAS_BYTE(0))) {
#line 2024 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(2728);
}
break;
case BAS_UBYTE(240u):;
#line 2025 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(682);
break;
case BAS_UBYTE(247u):;
#line 2026 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(1023);
break;
case BAS_UBYTE(241u):;
#line 2027 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(1705);
break;
case BAS_UBYTE(245u):;
case BAS_UBYTE(246u):;
#line 2028 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(2046);
break;
case BAS_UBYTE(244u):;
#line 2029 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(2387);
break;
default:;
#line 2030 "cpu.bas"
PPU_u.ROWCLASS_i = BAS_INT(1364);
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CPUTICK */
#line 938 "cpu.bas"
void CPUTICK_f(BAS_INT W_i)
{
B_ERR_FRAME_SUB_BEGIN();
#line 941 "cpu.bas"
PPUTICK_f();
#line 942 "cpu.bas"
PPUTICK_f();
#line 943 "cpu.bas"
PPUTICK_f();
#line 945 "cpu.bas"
APUTICK_f(W_i);
#line 946 "cpu.bas"
CPU_u.CYCLECOUNTER_Y = ((CPU_u.CYCLECOUNTER_Y + BAS_UBYTE(1u)) & BAS_UBYTE(255u));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB JOYSTROBE */
#line 1018 "cpu.bas"
void JOYSTROBE_f(BAS_UBYTE HOW_Y)
{
#line 1019 "cpu.bas"
static BAS_UBYTE PLAYER2_Y { };
#line 1019 "cpu.bas"
static BAS_UBYTE PLAYER1_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1021 "cpu.bas"
if((HOW_Y == BAS_BYTE(0))) {
#line 1023 "cpu.bas"
goto subfunc_exit;
}
#line 1024 "cpu.bas"
switch(
#line 1023 "cpu.bas"
B_FuncINP(BAS_UBYTE(96u))) {
case BAS_UBYTE(72u):;
#line 1025 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(16u);
break;
case BAS_UBYTE(200u):;
#line 1025 "cpu.bas"
PLAYER1_Y &= BAS_BYTE(-17);
break;
case BAS_UBYTE(80u):;
#line 1026 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(32u);
break;
case BAS_UBYTE(208u):;
#line 1026 "cpu.bas"
PLAYER1_Y &= BAS_BYTE(-33);
break;
case BAS_UBYTE(75u):;
#line 1027 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(64u);
break;
case BAS_UBYTE(203u):;
#line 1027 "cpu.bas"
PLAYER1_Y &= BAS_BYTE(-65);
break;
case BAS_UBYTE(77u):;
#line 1028 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(128u);
break;
case BAS_UBYTE(205u):;
#line 1028 "cpu.bas"
PLAYER1_Y &= BAS_INT(-129);
break;
case BAS_UBYTE(25u):;
#line 1030 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(8u);
break;
case BAS_INT(153):;
#line 1030 "cpu.bas"
PLAYER1_Y &= BAS_BYTE(-9);
break;
case BAS_UBYTE(35u):;
#line 1031 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(4u);
break;
case BAS_INT(163):;
#line 1031 "cpu.bas"
PLAYER1_Y &= BAS_BYTE(-5);
break;
case BAS_UBYTE(30u):;
#line 1032 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(2u);
break;
case BAS_INT(158):;
#line 1032 "cpu.bas"
PLAYER1_Y &= BAS_BYTE(-3);
break;
case BAS_UBYTE(32u):;
#line 1033 "cpu.bas"
PLAYER1_Y |= BAS_UBYTE(1u);
break;
case BAS_INT(160):;
#line 1033 "cpu.bas"
PLAYER1_Y &= BAS_BYTE(-2);
break;
}
#line 1036 "cpu.bas"
JOYNEXT_Y_a[BAS_BYTE(0)] = PLAYER1_Y;
#line 1037 "cpu.bas"
JOYNEXT_Y_a[BAS_UBYTE(1u)] = PLAYER2_Y;
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUTICK */
#line 1389 "cpu.bas"
void APUTICK_f(BAS_INT W_i)
{
#line 1398 "cpu.bas"
BAS_SGN MIX_z { };
#line 1413 "cpu.bas"
BAS_INT Q5_i { };
#line 1390 "cpu.bas"
static BAS_INT CYCLESACCUMULATED_i { };
#line 1398 "cpu.bas"
BAS_ULONG A_U { };
#line 1390 "cpu.bas"
static BAS_ULONG APUCYCLECOUNTER_U { };
B_ERR_FRAME_SUB_BEGIN();
#line 1392 "cpu.bas"
if((APU_u.FRAMEDELAY_i == BAS_BYTE(0))) {
#line 1392 "cpu.bas"
APUFRAMETICK_f();
}
#line 1393 "cpu.bas"
APU_u.FRAMEDELAY_i -= BAS_UBYTE(1u);
#line 1395 "cpu.bas"
APUCYCLECOUNTER_U += SAMPLERATE_l;
#line 1396 "cpu.bas"
if((CYCLESACCUMULATED_i < BAS_INT(32512))) {
#line 1396 "cpu.bas"
CYCLESACCUMULATED_i += BAS_UBYTE(1u);
}
#line 1399 "cpu.bas"
A_U = 
#line 1399 "cpu.bas"
(BAS_LNG)std::round((1789800.f * TURBOFACTOR_z));
#line 1401 "cpu.bas"
if((APUCYCLECOUNTER_U >= A_U)) {
#line 1401 "cpu.bas"
APUCYCLECOUNTER_U -= A_U;
#line 1403 "cpu.bas"
if((
#line 1403 "cpu.bas"
B_Funcqb64SNDRAWLEN() >= 0.5f)) {
#line 1404 "cpu.bas"
goto subfunc_exit;
}
} else {
#line 1401 "cpu.bas"
if((
#line 1404 "cpu.bas"
B_Funcqb64SNDRAWLEN() > 0.10000000149011611938f)) {
#line 1407 "cpu.bas"
goto subfunc_exit;
}
}
#line 1414 "cpu.bas"
Q5_i = BAS_BYTE(0);
#line 1418 "cpu.bas"
MIX_z = (((-0.5f + APUMIXFUN_f(95.87999725341796875f, (100.f + APUMIXFUN_f(8128.f, (APUTICKSQUARE_f(BAS_BYTE(0), CYCLESACCUMULATED_i) + APUTICKSQUARE_f(BAS_UBYTE(1u), CYCLESACCUMULATED_i)), -100.f)), 0.f)) + APUMIXFUN_f(159.7899932861328125f, (100.f + APUMIXFUN_f(1.f, (((APUTICKTRIANGLE_f(CYCLESACCUMULATED_i) / (BAS_DBL)8227.f) + (APUTICKNOISE_f(CYCLESACCUMULATED_i) / (BAS_DBL)12241.f)) + (APUTICKDPCM_f(CYCLESACCUMULATED_i, W_i) / (BAS_DBL)22638.f)), BAS_BYTE(-100))), 0.f)) + APUMIXFUN_f(95.87999725341796875f, (100.f + APUMIXFUN_f(32512.f, Q5_i, -100.f)), 0.f));
#line 1419 "cpu.bas"
B_Stmtqb64SNDRAW(MIX_z);
#line 1421 "cpu.bas"
CYCLESACCUMULATED_i = BAS_BYTE(0);
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB SETFLAGS */
#line 930 "cpu.bas"
void SETFLAGS_f(BAS_UBYTE PVALUE_Y)
{
B_ERR_FRAME_SUB_BEGIN();
#line 931 "cpu.bas"
CPU_u.C_i = (PVALUE_Y & BAS_UBYTE(1u));
#line 932 "cpu.bas"
CPU_u.I_Y = (PVALUE_Y & BAS_UBYTE(4u));
#line 933 "cpu.bas"
CPU_u.D_y = (((PVALUE_Y & BAS_UBYTE(8u)) != BAS_BYTE(0)) ? -1 : 0);
#line 934 "cpu.bas"
CPU_u.V_Y = (PVALUE_Y & BAS_UBYTE(64u));
#line 935 "cpu.bas"
CPU_u.NZ_i = ((((PVALUE_Y & BAS_UBYTE(128u)) * BAS_UBYTE(2u)) + BAS_UBYTE(2u)) - (PVALUE_Y & BAS_UBYTE(2u)));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUACCESS */
#line 2165 "cpu.bas"
void PPUACCESS_f(BAS_INT W_i)
{
#line 2231 "cpu.bas"
BAS_INT B_i { };
#line 2230 "cpu.bas"
BAS_INT A_i { };
#line 2195 "cpu.bas"
BAS_UBYTE A_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 2167 "cpu.bas"
if(W_i) {
#line 2167 "cpu.bas"
switch((ADDR_i & BAS_UBYTE(7u))) {
case BAS_UBYTE(1u):;
#line 2167 "cpu.bas"
goto L32_L_WRITE2001;
break;
case BAS_UBYTE(2u):;
#line 2167 "cpu.bas"
goto L33_L_NOTHING;
break;
case BAS_UBYTE(3u):;
#line 2167 "cpu.bas"
goto L34_L_WRITE2003;
break;
case BAS_UBYTE(4u):;
#line 2167 "cpu.bas"
goto L35_L_WRITE2004;
break;
case BAS_UBYTE(5u):;
#line 2167 "cpu.bas"
goto L36_L_WRITE2005;
break;
case BAS_UBYTE(6u):;
#line 2167 "cpu.bas"
goto L37_L_WRITE2006;
break;
case BAS_UBYTE(7u):;
#line 2167 "cpu.bas"
goto L38_L_WRITE2007;
break;
}
#line 2170 "cpu.bas"
PPU_u.INC_Y = (PPUIOBYTE_Y & BAS_UBYTE(4u));
#line 2171 "cpu.bas"
PPU_u.SPADDR_i = ((PPUIOBYTE_Y & BAS_UBYTE(8u)) * BAS_INT(512));
#line 2172 "cpu.bas"
PPU_u.BGADDR_i = ((PPUIOBYTE_Y & BAS_UBYTE(16u)) * BAS_INT(256));
#line 2173 "cpu.bas"
PPU_u.SPSIZE_Y = (((PPUIOBYTE_Y & BAS_UBYTE(32u)) / BAS_UBYTE(4u)) + BAS_UBYTE(8u));
#line 2175 "cpu.bas"
PPU_u.NMIENABLED_Y = ((PPUIOBYTE_Y / BAS_UBYTE(128u)) & BAS_UBYTE(1u));
#line 2176 "cpu.bas"
PPU_u.BASENTAS_i = ((PPUIOBYTE_Y & BAS_UBYTE(3u)) * BAS_INT(1024));
#line 2178 "cpu.bas"
goto subfunc_exit;
#line 2178 "cpu.bas"
L32_L_WRITE2001: ;
#line 2179 "cpu.bas"
PPU_u.GRAYSCALE_Y = (BAS_UBYTE(63u) - (BAS_UBYTE(15u) * (PPUIOBYTE_Y & BAS_UBYTE(1u))));
#line 2180 "cpu.bas"
PPU_u.SHOWBG8_Y = (PPUIOBYTE_Y & BAS_UBYTE(2u));
#line 2181 "cpu.bas"
PPU_u.SHOWSP8_Y = (PPUIOBYTE_Y & BAS_UBYTE(4u));
#line 2182 "cpu.bas"
PPU_u.SHOWBG_Y = (PPUIOBYTE_Y & BAS_UBYTE(8u));
#line 2183 "cpu.bas"
PPU_u.SHOWSP_Y = (PPUIOBYTE_Y & BAS_UBYTE(16u));
#line 2184 "cpu.bas"
PPU_u.EMPHASISPHASES_l = BAS_BYTE(0);
#line 2185 "cpu.bas"
if((PPUIOBYTE_Y & BAS_UBYTE(32u))) {
#line 2185 "cpu.bas"
PPU_u.EMPHASISPHASES_l |= 16519104;
}
#line 2186 "cpu.bas"
if((PPUIOBYTE_Y & BAS_UBYTE(64u))) {
#line 2186 "cpu.bas"
PPU_u.EMPHASISPHASES_l |= 64512;
}
#line 2187 "cpu.bas"
if((PPUIOBYTE_Y & BAS_UBYTE(128u))) {
#line 2187 "cpu.bas"
PPU_u.EMPHASISPHASES_l |= 1032384;
}
#line 2188 "cpu.bas"
PPU_u.SHOW_y = (((PPU_u.SHOWSP_Y != BAS_BYTE(0)) ? -1 : 0) | ((PPU_u.SHOWBG_Y != BAS_BYTE(0)) ? -1 : 0));
#line 2189 "cpu.bas"
PPUSETROWCLASS_f();
#line 2191 "cpu.bas"
goto subfunc_exit;
#line 2191 "cpu.bas"
L34_L_WRITE2003: ;
#line 2192 "cpu.bas"
PPU_u.OAMPOSLO_Y = (PPUIOBYTE_Y & BAS_UBYTE(3u));
#line 2193 "cpu.bas"
PPU_u.OAMPOSHI_Y = (PPUIOBYTE_Y & BAS_UBYTE(252u));
#line 2195 "cpu.bas"
goto subfunc_exit;
#line 2195 "cpu.bas"
L35_L_WRITE2004: ;
#line 2196 "cpu.bas"
A_Y = PPUIOBYTE_Y;
#line 2197 "cpu.bas"
if((PPU_u.OAMPOSLO_Y == BAS_UBYTE(2u))) {
#line 2197 "cpu.bas"
A_Y &= BAS_UBYTE(227u);
}
#line 2199 "cpu.bas"
OAM_Y_a[PPUGETOAMPOS_f()] = A_Y;
#line 2199 "cpu.bas"
PPUINCROAMPOS_f();
#line 2201 "cpu.bas"
goto subfunc_exit;
#line 2201 "cpu.bas"
L36_L_WRITE2005: ;
#line 2203 "cpu.bas"
if((PPU_u.OFFSETTOGGLE_Y == BAS_BYTE(0))) {
#line 2203 "cpu.bas"
PPU_u.FINEXS_Y = (PPUIOBYTE_Y & BAS_UBYTE(7u));
#line 2204 "cpu.bas"
PPU_u.FINEXSDIV_i = (BAS_UBYTE(1u) << (BAS_UBYTE(15u) - PPU_u.FINEXS_Y));
#line 2205 "cpu.bas"
PPU_u.XCOARSES_Y = (PPUIOBYTE_Y / BAS_UBYTE(8u));
} else {
#line 2207 "cpu.bas"
PPU_u.FINEYS_Y = (PPUIOBYTE_Y & BAS_UBYTE(7u));
#line 2208 "cpu.bas"
PPU_u.YCOARSES_Y = (PPUIOBYTE_Y / BAS_UBYTE(8u));
}
#line 2210 "cpu.bas"
PPU_u.OFFSETTOGGLE_Y ^= BAS_UBYTE(1u);
#line 2212 "cpu.bas"
goto subfunc_exit;
#line 2212 "cpu.bas"
L37_L_WRITE2006: ;
#line 2214 "cpu.bas"
if((PPU_u.OFFSETTOGGLE_Y == BAS_BYTE(0))) {
#line 2214 "cpu.bas"
PPU_u.YCOARSES_Y = ((PPU_u.YCOARSES_Y & BAS_UBYTE(7u)) | ((PPUIOBYTE_Y & BAS_UBYTE(3u)) * BAS_UBYTE(8u)));
#line 2215 "cpu.bas"
PPU_u.BASENTAS_i = (((PPUIOBYTE_Y / BAS_UBYTE(4u)) & BAS_UBYTE(3u)) * BAS_INT(1024));
#line 2216 "cpu.bas"
PPU_u.FINEYS_Y = ((PPUIOBYTE_Y / BAS_UBYTE(16u)) & BAS_UBYTE(3u));
} else {
#line 2220 "cpu.bas"
PPU_u.XCOARSES_Y = (PPUIOBYTE_Y & BAS_UBYTE(31u));
#line 2221 "cpu.bas"
PPU_u.YCOARSES_Y = ((PPU_u.YCOARSES_Y & BAS_UBYTE(24u)) | (PPUIOBYTE_Y / BAS_UBYTE(32u)));
#line 2222 "cpu.bas"
PPUCOPYVADDR_f();
#line 2223 "cpu.bas"
UsingFormatter ("PPU 2006: Vaddr=\\  \\").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f(PPUGETVADDR_f(), BAS_UBYTE(4u))) << PrintCRLFtag{}; 
}
#line 2225 "cpu.bas"
PPU_u.OFFSETTOGGLE_Y ^= BAS_UBYTE(1u);
#line 2227 "cpu.bas"
goto subfunc_exit;
#line 2227 "cpu.bas"
L38_L_WRITE2007: ;
#line 2228 "cpu.bas"
if(((BAS_INT(0) && (PPUIOBYTE_Y >= BAS_UBYTE(32u))) && (PPUIOBYTE_Y < BAS_UBYTE(128u)))) {
#line 2228 "cpu.bas"
GET_STDOUT() << 
#line 2228 "cpu.bas"
B_FuncCHR_S(PPUIOBYTE_Y); 
}
#line 2230 "cpu.bas"
A_i = PPUGETVADDR_f();
#line 2231 "cpu.bas"
B_i = A_i;
#line 2233 "cpu.bas"
if(((A_i & BAS_INT(16128)) == BAS_INT(16128))) {
#line 2234 "cpu.bas"
if(((B_i & BAS_UBYTE(3u)) == BAS_BYTE(0))) {
#line 2234 "cpu.bas"
B_i &= BAS_UBYTE(15u);
}
#line 2235 "cpu.bas"
PRAM_Y_a[(B_i & BAS_UBYTE(31u))] = (PPUIOBYTE_Y & BAS_UBYTE(63u));
#line 2236 "cpu.bas"
PPU_u.ADDRESSLINE_i = A_i;
} else {
#line 2238 "cpu.bas"
PPU_u.ADDRESSLINE_i = (A_i | BAS_UINT(49152u));
#line 2239 "cpu.bas"
PPU_u.READBUFFER_i = (PPUIOBYTE_Y | BAS_INT(256));
}
#line 2241 "cpu.bas"
if(BAS_INT(0)) {
#line 2241 "cpu.bas"
UsingFormatter ("PPU 2007 write. Vaddr=\\  \\, line=\\  \\, buffer=\\  \\").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f(PPUGETVADDR_f(), BAS_UBYTE(4u)), HEXS_f(PPU_u.ADDRESSLINE_i, BAS_UBYTE(4u)), HEXS_f(PPU_u.READBUFFER_i, BAS_UBYTE(4u))) << PrintCRLFtag{}; 
}
#line 2244 "cpu.bas"
L39_L_INCR2007: ;
#line 2244 "cpu.bas"
if((PPU_u.ROWCLASS_i < BAS_INT(682))) {
#line 2244 "cpu.bas"
PPUINCRVADDRVERT_f();
} else {
#line 2244 "cpu.bas"
PPUINCRVADDR2007_f();
}
#line 2246 "cpu.bas"
goto subfunc_exit;
} else {
#line 2247 "cpu.bas"
switch((ADDR_i & BAS_UBYTE(7u))) {
case BAS_UBYTE(1u):;
#line 2247 "cpu.bas"
goto L33_L_NOTHING;
break;
case BAS_UBYTE(2u):;
#line 2247 "cpu.bas"
goto L40_L_READ2002;
break;
case BAS_UBYTE(3u):;
#line 2247 "cpu.bas"
goto L33_L_NOTHING;
break;
case BAS_UBYTE(4u):;
#line 2247 "cpu.bas"
goto L41_L_READ2004;
break;
case BAS_UBYTE(5u):;
#line 2247 "cpu.bas"
goto L33_L_NOTHING;
break;
case BAS_UBYTE(6u):;
#line 2247 "cpu.bas"
goto L33_L_NOTHING;
break;
case BAS_UBYTE(7u):;
#line 2247 "cpu.bas"
goto L42_L_READ2007;
break;
}
#line 2248 "cpu.bas"
L33_L_NOTHING: ;
#line 2249 "cpu.bas"
goto subfunc_exit;
#line 2249 "cpu.bas"
L40_L_READ2002: ;
#line 2250 "cpu.bas"
PPUIOBYTE_Y = (((PPUIOBYTE_Y & BAS_UBYTE(31u)) | PPU_u.SPOVERFLOW_Y) | PPU_u.SP0HIT_Y);
#line 2251 "cpu.bas"
if((PPU_u.INVBLANK_y & BAS_UBYTE(2u))) {
#line 2251 "cpu.bas"
PPUIOBYTE_Y |= BAS_UBYTE(128u);
}
#line 2252 "cpu.bas"
PPU_u.INVBLANK_y = BAS_BYTE(0);
#line 2253 "cpu.bas"
PPU_u.OFFSETTOGGLE_Y = BAS_BYTE(0);
#line 2255 "cpu.bas"
goto subfunc_exit;
#line 2255 "cpu.bas"
L41_L_READ2004: ;
#line 2256 "cpu.bas"
A_Y = OAM_Y_a[PPUGETOAMPOS_f()];
#line 2258 "cpu.bas"
PPUIOBYTE_Y = A_Y;
#line 2260 "cpu.bas"
goto subfunc_exit;
#line 2260 "cpu.bas"
L42_L_READ2007: ;
#line 2261 "cpu.bas"
A_i = PPUGETVADDR_f();
#line 2262 "cpu.bas"
B_i = A_i;
#line 2264 "cpu.bas"
if(((A_i & BAS_INT(16128)) == BAS_INT(16128))) {
#line 2265 "cpu.bas"
if(((B_i & BAS_UBYTE(3u)) == BAS_BYTE(0))) {
#line 2265 "cpu.bas"
B_i &= BAS_UBYTE(15u);
}
#line 2266 "cpu.bas"
PPUIOBYTE_Y = ((PPUIOBYTE_Y & BAS_UBYTE(192u)) | PRAM_Y_a[(B_i & BAS_UBYTE(31u))]);
#line 2267 "cpu.bas"
PPU_u.ADDRESSLINE_i = A_i;
} else {
#line 2269 "cpu.bas"
PPUIOBYTE_Y = (PPU_u.READBUFFER_i & BAS_UBYTE(255u));
}
#line 2271 "cpu.bas"
PPU_u.ADDRESSLINE_i = (A_i | BAS_INT(16384));
#line 2272 "cpu.bas"
PPU_u.READBUFFER_i = (PPUIOBYTE_Y | BAS_INT(256));
#line 2273 "cpu.bas"
if(BAS_INT(0)) {
#line 2273 "cpu.bas"
UsingFormatter ("PPU 2007  read. Vaddr=\\  \\, line=\\  \\, buffer=\\  \\").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f(PPUGETVADDR_f(), BAS_UBYTE(4u)), HEXS_f(PPU_u.ADDRESSLINE_i, BAS_UBYTE(4u)), HEXS_f(PPU_u.READBUFFER_i, BAS_UBYTE(4u))) << PrintCRLFtag{}; 
}
#line 2275 "cpu.bas"
goto L39_L_INCR2007;
}
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPURENDER */
#line 2679 "cpu.bas"
void PPURENDER_f(BAS_LNG MODE_l)
{
#line 2699 "cpu.bas"
BAS_INT HI_i { };
#line 2699 "cpu.bas"
BAS_INT LO_i { };
#line 2699 "cpu.bas"
BAS_INT EMP_i { };
#line 2680 "cpu.bas"
BAS_INT PHASEBITMASK_i { };
#line 2680 "cpu.bas"
BAS_BYTE V_y { };
#line 2680 "cpu.bas"
BAS_UBYTE A_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 2683 "cpu.bas"
switch(MODE_l) {
case BAS_BYTE(-1):;
#line 2684 "cpu.bas"
for(A_Y = BAS_BYTE(0);A_Y < BAS_INT(8);A_Y += BAS_BYTE(1)) {
#line 2684 "cpu.bas"
TELEVISIONDECODE_f(BAS_BYTE(0));
}
break;
case BAS_BYTE(-2):;
#line 2686 "cpu.bas"
for(A_Y = BAS_BYTE(0);A_Y < BAS_INT(8);A_Y += BAS_BYTE(1)) {
#line 2686 "cpu.bas"
TELEVISIONDECODE_f(BAS_UBYTE(33u));
}
break;
case BAS_BYTE(-3):;
#line 2688 "cpu.bas"
PHASEBITMASK_i = (BAS_UBYTE(1u) << (((PPU_u.CYCLECOUNT_U * BAS_UBYTE(8u)) - BAS_UBYTE(8u)) % BAS_UBYTE(12u)));
#line 2691 "cpu.bas"
for(A_Y = BAS_BYTE(0);A_Y < BAS_INT(8);A_Y += BAS_BYTE(1)) {
#line 2691 "cpu.bas"
PHASEBITMASK_i *= BAS_UBYTE(2u);
#line 2692 "cpu.bas"
V_y = BAS_UBYTE(60u);
#line 2693 "cpu.bas"
if((PHASEBITMASK_i >= BAS_UBYTE(64u))) {
#line 2694 "cpu.bas"
if((PHASEBITMASK_i == BAS_INT(4096))) {
#line 2694 "cpu.bas"
PHASEBITMASK_i = BAS_UBYTE(1u);
} else {
#line 2694 "cpu.bas"
V_y = BAS_UBYTE(14u);
}
}
#line 2696 "cpu.bas"
TELEVISIONDECODE_f(V_y);
}
break;
default:;
#line 2701 "cpu.bas"
EMP_i = (MODE_l & BAS_UBYTE(63u));
#line 2702 "cpu.bas"
LO_i = SIGNALLO_i_a[EMP_i];
#line 2703 "cpu.bas"
HI_i = SIGNALHI_i_a[EMP_i];
#line 2704 "cpu.bas"
EMP_i = (MODE_l / BAS_UBYTE(64u));
#line 2705 "cpu.bas"
PHASEBITMASK_i = (BAS_UBYTE(1u) << (((PPU_u.CYCLECOUNT_U * BAS_UBYTE(8u)) - (MODE_l & BAS_UBYTE(15u))) % BAS_UBYTE(12u)));
#line 2708 "cpu.bas"
for(A_Y = BAS_BYTE(0);A_Y < BAS_INT(8);A_Y += BAS_BYTE(1)) {
#line 2708 "cpu.bas"
PHASEBITMASK_i *= BAS_UBYTE(2u);
#line 2709 "cpu.bas"
V_y = HI_i;
#line 2710 "cpu.bas"
if((PHASEBITMASK_i >= BAS_UBYTE(64u))) {
#line 2711 "cpu.bas"
if((PHASEBITMASK_i == BAS_INT(4096))) {
#line 2711 "cpu.bas"
PHASEBITMASK_i = BAS_UBYTE(1u);
} else {
#line 2712 "cpu.bas"
V_y = LO_i;
}
}
#line 2714 "cpu.bas"
if((PHASEBITMASK_i & EMP_i)) {
#line 2714 "cpu.bas"
V_y -= (V_y / BAS_UBYTE(4u));
}
#line 2716 "cpu.bas"
TELEVISIONDECODE_f(V_y);
}
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB WBR */
#line 902 "cpu.bas"
BAS_INT WBR_f(BAS_UBYTE T_Y)
{
BAS_INT FunctionReturn_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 903 "cpu.bas"
FunctionReturn_i = (T_Y & BAS_UBYTE(255u));
#line 905 "cpu.bas"
WB_f(T_Y);
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUTICKSQUARE */
#line 1253 "cpu.bas"
BAS_INT APUTICKSQUARE_f(BAS_UBYTE C_Y, BAS_INT CYCLESACCUMULATED_i)
{
BAS_INT FunctionReturn_i { };
#line 1254 "cpu.bas"
BAS_INT WL_i { };
#line 1254 "cpu.bas"
BAS_UBYTE VOL_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1256 "cpu.bas"
VOL_Y = APUCHANNELS_u_a[C_Y].LEVEL_Y;
#line 1257 "cpu.bas"
FunctionReturn_i = VOL_Y;
#line 1258 "cpu.bas"
if(((APU_u.CHANNELSENABLED_Y & (BAS_UBYTE(1u) << C_Y)) == BAS_BYTE(0))) {
#line 1259 "cpu.bas"
goto subfunc_exit;
}
#line 1260 "cpu.bas"
WL_i = (((APUCHANNELS_u_a[C_Y].WAVELENGTH_i + BAS_UBYTE(1u)) * (BAS_UBYTE(2u) * TURBOFACTOR_z)) + BAS_UBYTE(1u));
#line 1261 "cpu.bas"
APUCHANNELS_u_a[C_Y].WAVECOUNTER_i -= CYCLESACCUMULATED_i;
#line 1262 "cpu.bas"
while((APUCHANNELS_u_a[C_Y].WAVECOUNTER_i <= BAS_BYTE(0))) {
#line 1263 "cpu.bas"
APUCHANNELS_u_a[C_Y].WAVECOUNTER_i += WL_i;
#line 1265 "cpu.bas"
if((WL_i >= BAS_UBYTE(8u))) {
#line 1265 "cpu.bas"
APUCHANNELS_u_a[C_Y].PHASE_Y = ((APUCHANNELS_u_a[C_Y].PHASE_Y * BAS_UBYTE(2u)) & BAS_UBYTE(255u));
#line 1266 "cpu.bas"
if((APUCHANNELS_u_a[C_Y].PHASE_Y == BAS_BYTE(0))) {
#line 1266 "cpu.bas"
APUCHANNELS_u_a[C_Y].PHASE_Y = BAS_UBYTE(1u);
}
}
}
#line 1275 "cpu.bas"
if((((((APUCHANNELS_u_a[C_Y].SWEEPENABLE_Y == BAS_BYTE(0)) || (APUCHANNELS_u_a[C_Y].SWEEPDECREASE_Y != BAS_BYTE(0))) || ((WL_i + (WL_i >> APUCHANNELS_u_a[C_Y].SWEEPSHIFT_Y)) < BAS_INT(2048))) && (APUCHANNELS_u_a[C_Y].DUTYCYCLE_Y & APUCHANNELS_u_a[C_Y].PHASE_Y)) || (APUCHANNELS_u_a[C_Y].LENGTHCOUNTER_Y == BAS_BYTE(0)))) {
#line 1275 "cpu.bas"
VOL_Y = BAS_BYTE(0);
} else {
#line 1277 "cpu.bas"
VOL_Y = APUCHANNELS_u_a[C_Y].ENVELOPE_Y;
}
#line 1280 "cpu.bas"
APUCHANNELS_u_a[C_Y].LEVEL_Y = VOL_Y;
#line 1281 "cpu.bas"
FunctionReturn_i = VOL_Y;
 subfunc_exit:; 
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB RBMAKEADDR */
#line 907 "cpu.bas"
void RBMAKEADDR_f(BAS_UBYTE S_Y)
{
B_ERR_FRAME_SUB_BEGIN();
#line 909 "cpu.bas"
if((BAS_ULONG(sizeof(S_Y)) == BAS_UBYTE(1u))) {
#line 909 "cpu.bas"
ADDR_i = ((RB_f() * BAS_INT(256)) + S_Y);
} else {
#line 913 "cpu.bas"
ADDR_i = RB_f();
#line 914 "cpu.bas"
if((ADDR_i & BAS_UBYTE(128u))) {
#line 914 "cpu.bas"
ADDR_i = ((((ADDR_i & BAS_UBYTE(127u)) * BAS_INT(256)) + S_Y) | BAS_UINT(32768u));
} else {
#line 914 "cpu.bas"
ADDR_i = ((ADDR_i * BAS_INT(256)) + S_Y);
}
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUGETVADDR12BIT */
#line 2037 "cpu.bas"
BAS_INT PPUGETVADDR12BIT_f()
{
BAS_INT FunctionReturn_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2038 "cpu.bas"
FunctionReturn_i = ((PPU_u.XCOARSE_Y | PPU_u.YCOARSE32_i) | PPU_u.BASENTA_i);
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CARTSETPRG */
#line 1522 "cpu.bas"
void CARTSETPRG_f(BAS_UBYTE SIZE_Y, BAS_UBYTE BASEADDR_Y, BAS_INT INDEX_i)
{
#line 1523 "cpu.bas"
BAS_INT B_i { };
#line 1523 "cpu.bas"
BAS_INT N_i { };
#line 1523 "cpu.bas"
BAS_INT V_i { };
#line 1523 "cpu.bas"
BAS_INT P_i { };
#line 1524 "cpu.bas"
BAS_LNG MATLOC_l { };
B_ERR_FRAME_SUB_BEGIN();
#line 1524 "cpu.bas"
P_i = (BASEADDR_Y / BAS_INT(32));
#line 1525 "cpu.bas"
V_i = (PRGSIZEPAGES_i + (INDEX_i * SIZE_Y));
#line 1527 "cpu.bas"
while(((P_i < ((BASEADDR_Y + SIZE_Y) / BAS_INT(32))) && (P_i < BAS_INT(8)))) {
#line 1528 "cpu.bas"
V_i &= (PRGSIZEPAGES_i + BAS_BYTE(-1));
#line 1530 "cpu.bas"
if(BAS_INT(-1)) {
#line 1530 "cpu.bas"
PRGBANKS_l_a[P_i] = (
#line 1530 "cpu.bas"
(BAS_LNG)std::round(V_i) * 256u);
} else {
#line 1533 "cpu.bas"
if((PRGBANKS_l_a[P_i] != V_i)) {
#line 1534 "cpu.bas"
PRGBANKS_l_a[P_i] = V_i;
#line 1534 "cpu.bas"
B_StmtGET(SWAPFILEHANDLE_l, ((SWAPPRGBASIS_l + (
#line 1534 "cpu.bas"
(BAS_LNG)std::round(V_i) * 16)) - BAS_UBYTE(1u)));
#line 1536 "cpu.bas"
B_StmtDEFSEG(
#line 1536 "cpu.bas"
B_FuncVARSEG(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))));
#line 1537 "cpu.bas"
MATLOC_l = (((P_i & BAS_INT(3)) * BAS_INT(8192)) + 
#line 1537 "cpu.bas"
B_FuncVARPTR(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))));
#line 1545 "cpu.bas"
for(N_i = BAS_UBYTE(1u);N_i <= BAS_INT(512);N_i += BAS_BYTE(1)) {
#line 1545 "cpu.bas"
B_StmtGET(SWAPFILEHANDLE_l);
#line 1547 "cpu.bas"
for(B_i = BAS_UBYTE(1u);B_i <= BAS_UBYTE(16u);B_i += BAS_BYTE(1)) {
#line 1547 "cpu.bas"
B_StmtPOKE(MATLOC_l, B_ASC_MID(BS_s, B_i));
#line 1548 "cpu.bas"
MATLOC_l += BAS_UBYTE(1u);
}
}
}
}
#line 1554 "cpu.bas"
P_i += BAS_UBYTE(1u);
#line 1555 "cpu.bas"
V_i += BAS_INT(32);
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CARTACCESS */
#line 1596 "cpu.bas"
void CARTACCESS_f(BAS_INT W_i)
{
#line 1752 "cpu.bas"
BAS_INT CONFIG_i { };
#line 1613 "cpu.bas"
BAS_UINT A_I { };
#line 1684 "cpu.bas"
BAS_UBYTE A_Y { };
#line 1608 "cpu.bas"
BAS_UBYTE ROMBYTE_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1598 "cpu.bas"
if((((((ADDR_i & BAS_UINT(32768u)) == BAS_BYTE(0)) && (MAPPERNUM_i != BAS_UBYTE(184u))) && (MAPPERNUM_i != BAS_UBYTE(140u))) && (MAPPERNUM_i != BAS_UBYTE(41u)))) {
#line 1598 "cpu.bas"
if((ADDR_i >= BAS_INT(24576))) {
#line 1600 "cpu.bas"
if((BAS_INT(0) && (W_i != BAS_BYTE(0)))) {
#line 1600 "cpu.bas"
GET_STDOUT() << 
#line 1600 "cpu.bas"
B_FuncCHR_S(IOBYTE_Y); 
}
#line 1601 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 1601 "cpu.bas"
IOBYTE_Y = WRAM_Y_a[(ADDR_i & BAS_INT(8191))];
} else {
#line 1601 "cpu.bas"
WRAM_Y_a[(ADDR_i & BAS_INT(8191))] = IOBYTE_Y;
}
#line 1603 "cpu.bas"
goto subfunc_exit;
}
#line 1605 "cpu.bas"
goto subfunc_exit;
}
#line 1608 "cpu.bas"
if((W_i == BAS_BYTE(0))) {
#line 1609 "cpu.bas"
if(BAS_BYTE(0)) {
#line 1610 "cpu.bas"
B_StmtDEFSEG(
#line 1610 "cpu.bas"
B_FuncVARSEG(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))));
#line 1611 "cpu.bas"
ROMBYTE_Y = 
#line 1611 "cpu.bas"
B_FuncPEEK((
#line 1611 "cpu.bas"
B_FuncVARPTR(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))) + (ADDR_i & BAS_INT(32767))));
} else {
#line 1613 "cpu.bas"
A_I = ADDR_i;
#line 1614 "cpu.bas"
ROMBYTE_Y = PRGROM_Y_a.Index(0,0,(PRGBANKS_l_a[(A_I / BAS_INT(8192))] + (A_I & BAS_INT(8191))));
}
#line 1617 "cpu.bas"
IOBYTE_Y = ROMBYTE_Y;
#line 1618 "cpu.bas"
if(BAS_INT(0)) {
#line 1618 "cpu.bas"
UsingFormatter ("Read \\  \\ = \\\\").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f((
#line 1618 "cpu.bas"
(BAS_LNG)std::round(ADDR_i) & 65535), BAS_UBYTE(4u)), HEXS_f(IOBYTE_Y, BAS_UBYTE(2u))) << PrintCRLFtag{}; 
}
#line 1620 "cpu.bas"
goto subfunc_exit;
}
#line 1626 "cpu.bas"
switch(MAPPERNUM_i) {
case BAS_BYTE(0):;
break;
case BAS_UBYTE(174u):;
#line 1630 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), ((ADDR_i & BAS_UBYTE(14u)) / BAS_UBYTE(2u)));
#line 1631 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), ((ADDR_i & BAS_UBYTE(112u)) / BAS_UBYTE(16u)));
#line 1632 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (((ADDR_i & BAS_UBYTE(112u)) / BAS_UBYTE(16u)) + ((ADDR_i & BAS_UBYTE(128u)) / BAS_UBYTE(128u))));
#line 1633 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + ((ADDR_i & BAS_UBYTE(1u)) * BAS_UBYTE(56u))));
break;
case BAS_UBYTE(225u):;
#line 1635 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), ((ADDR_i & BAS_UBYTE(63u)) | ((ADDR_i & BAS_INT(16384)) / BAS_UBYTE(128u))));
#line 1636 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (((ADDR_i & BAS_INT(4032)) / BAS_UBYTE(64u)) | ((ADDR_i & BAS_INT(16384)) / BAS_UBYTE(128u))));
#line 1637 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (((((ADDR_i & BAS_INT(4032)) / BAS_UBYTE(64u)) | ((ADDR_i & BAS_INT(16384)) / BAS_UBYTE(128u))) + BAS_UBYTE(1u)) - ((ADDR_i & BAS_INT(4096)) / BAS_INT(4096))));
#line 1638 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((ADDR_i & BAS_INT(8192)) / BAS_INT(8192)) * BAS_UBYTE(56u))));
break;
case BAS_UBYTE(201u):;
#line 1640 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (ADDR_i & BAS_UBYTE(15u)));
#line 1641 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), (ADDR_i & BAS_UBYTE(15u)));
break;
case BAS_UBYTE(200u):;
#line 1643 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (ADDR_i & BAS_UBYTE(7u)));
#line 1644 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (ADDR_i & BAS_UBYTE(7u)));
#line 1645 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (ADDR_i & BAS_UBYTE(7u)));
#line 1646 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((ADDR_i & BAS_UBYTE(8u)) / BAS_UBYTE(8u)) * BAS_UBYTE(56u))));
break;
case BAS_UBYTE(57u):;
#line 1648 "cpu.bas"
MAPREG_Y_a[((ADDR_i & BAS_INT(2048)) / BAS_INT(2048))] = IOBYTE_Y;
#line 1649 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(7u)) | (MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(7u))) | ((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(64u)) / BAS_UBYTE(8u))));
#line 1650 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), ((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(224u)) / BAS_UBYTE(32u)));
#line 1651 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(224u)) / BAS_UBYTE(32u)) + ((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(16u)) / BAS_UBYTE(16u))));
#line 1652 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(8u)) / BAS_UBYTE(8u)) * BAS_UBYTE(56u))));
break;
case BAS_UBYTE(58u):;
#line 1654 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), ((ADDR_i & BAS_UBYTE(56u)) / BAS_UBYTE(8u)));
#line 1655 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (ADDR_i & BAS_UBYTE(7u)));
#line 1656 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (((ADDR_i & BAS_UBYTE(7u)) + BAS_UBYTE(1u)) - ((ADDR_i & BAS_UBYTE(64u)) / BAS_UBYTE(64u))));
#line 1657 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((ADDR_i & BAS_UBYTE(128u)) / BAS_UBYTE(128u)) * BAS_UBYTE(56u))));
break;
case BAS_UBYTE(226u):;
#line 1659 "cpu.bas"
MAPREG_Y_a[(ADDR_i & BAS_UBYTE(1u))] = IOBYTE_Y;
#line 1660 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(31u)) | ((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(128u)) / BAS_UBYTE(4u))) | ((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(1u)) * BAS_UBYTE(64u))));
#line 1661 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (((((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(31u)) | ((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(128u)) / BAS_UBYTE(4u))) | ((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(1u)) * BAS_UBYTE(64u))) + BAS_UBYTE(1u)) - ((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(32u)) / BAS_UBYTE(32u))));
#line 1662 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(64u)) / BAS_UBYTE(64u)) * BAS_UBYTE(56u))));
break;
case BAS_UBYTE(231u):;
#line 1664 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (ADDR_i & BAS_UBYTE(30u)));
#line 1665 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), ((ADDR_i & BAS_UBYTE(30u)) + ((ADDR_i & BAS_UBYTE(32u)) / BAS_UBYTE(32u))));
#line 1666 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((ADDR_i & BAS_UBYTE(128u)) / BAS_UBYTE(128u)) * BAS_UBYTE(56u))));
break;
case BAS_UBYTE(203u):;
#line 1668 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (IOBYTE_Y & BAS_UBYTE(3u)));
#line 1669 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (IOBYTE_Y / BAS_UBYTE(4u)));
#line 1670 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (IOBYTE_Y / BAS_UBYTE(4u)));
break;
case BAS_UBYTE(227u):;
#line 1672 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((ADDR_i & BAS_UBYTE(2u)) / BAS_UBYTE(2u)) * BAS_UBYTE(56u))));
#line 1685 "cpu.bas"
A_Y = (((ADDR_i & BAS_UBYTE(124u)) / BAS_UBYTE(4u)) | ((ADDR_i & BAS_INT(256)) / BAS_UBYTE(8u)));
#line 1687 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), A_Y);
#line 1688 "cpu.bas"
if((ADDR_i & BAS_UBYTE(128u))) {
#line 1689 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (A_Y + (ADDR_i & BAS_UBYTE(1u))));
} else {
#line 1688 "cpu.bas"
if((ADDR_i & BAS_INT(512))) {
#line 1691 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (A_Y | BAS_UBYTE(7u)));
} else {
#line 1693 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (A_Y & BAS_UBYTE(56u)));
}
}
break;
case BAS_UBYTE(41u):;
#line 1696 "cpu.bas"
if(((ADDR_i & BAS_UINT(63488u)) == BAS_INT(24576))) {
#line 1697 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(520) + (((ADDR_i & BAS_UBYTE(32u)) / BAS_UBYTE(32u)) * BAS_UBYTE(56u))));
#line 1698 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), (MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(7u)));
#line 1699 "cpu.bas"
MAPREG_Y_a[BAS_BYTE(0)] = (ADDR_i & BAS_UBYTE(4u));
#line 1700 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(1u)] = ((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(3u)) | ((ADDR_i / BAS_UBYTE(2u)) & BAS_UBYTE(12u)));
} else {
#line 1696 "cpu.bas"
if((ADDR_i & BAS_UINT(32768u))) {
#line 1702 "cpu.bas"
if(MAPREG_Y_a[BAS_BYTE(0)]) {
#line 1702 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(1u)] = ((MAPREG_Y_a[BAS_UBYTE(1u)] & BAS_UBYTE(12u)) | (IOBYTE_Y & BAS_UBYTE(3u)));
}
}
}
#line 1704 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), MAPREG_Y_a[BAS_UBYTE(1u)]);
break;
case BAS_UBYTE(66u):;
#line 1706 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (IOBYTE_Y & BAS_UBYTE(3u)));
#line 1707 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), ((IOBYTE_Y / BAS_UBYTE(16u)) & BAS_UBYTE(3u)));
break;
case BAS_UBYTE(140u):;
#line 1709 "cpu.bas"
if(((ADDR_i & BAS_UINT(57344u)) == BAS_INT(24576))) {
#line 1710 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (IOBYTE_Y & BAS_UBYTE(3u)));
#line 1711 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), ((IOBYTE_Y / BAS_UBYTE(16u)) & BAS_UBYTE(3u)));
}
break;
case BAS_UBYTE(2u):;
#line 1714 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), IOBYTE_Y);
break;
case BAS_UBYTE(3u):;
#line 1716 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (IOBYTE_Y & BAS_UBYTE(3u)));
break;
case BAS_UBYTE(87u):;
#line 1718 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (IOBYTE_Y / BAS_UBYTE(2u)));
break;
case BAS_UBYTE(89u):;
#line 1720 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), ((IOBYTE_Y & BAS_UBYTE(7u)) + ((IOBYTE_Y & BAS_UBYTE(128u)) / BAS_UBYTE(16u))));
#line 1721 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), ((IOBYTE_Y & BAS_UBYTE(112u)) / BAS_UBYTE(16u)));
#line 1722 "cpu.bas"
CARTSETMIRRORING_f((BAS_BYTE(0) + (((IOBYTE_Y & BAS_UBYTE(8u)) / BAS_UBYTE(8u)) * BAS_INT(585))));
break;
case BAS_UBYTE(93u):;
#line 1724 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), ((IOBYTE_Y & BAS_UBYTE(112u)) / BAS_UBYTE(16u)));
break;
case BAS_UBYTE(184u):;
#line 1726 "cpu.bas"
if(((ADDR_i & BAS_UINT(57344u)) == BAS_INT(24576))) {
#line 1727 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (IOBYTE_Y & BAS_UBYTE(7u)));
#line 1728 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_UBYTE(16u), (((IOBYTE_Y & BAS_UBYTE(112u)) / BAS_UBYTE(16u)) | BAS_UBYTE(4u)));
}
break;
case BAS_UBYTE(71u):;
#line 1731 "cpu.bas"
if((ADDR_i & BAS_INT(16384))) {
#line 1732 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), IOBYTE_Y);
}
break;
case BAS_UBYTE(11u):;
#line 1735 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), (IOBYTE_Y & BAS_UBYTE(3u)));
#line 1736 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (IOBYTE_Y / BAS_UBYTE(16u)));
break;
case BAS_UBYTE(185u):;
#line 1739 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), ((IOBYTE_Y & BAS_UBYTE(3u)) | ((IOBYTE_Y / BAS_UBYTE(4u)) & BAS_UBYTE(12u))));
break;
case BAS_UBYTE(7u):;
#line 1741 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), (IOBYTE_Y & BAS_UBYTE(15u)));
#line 1742 "cpu.bas"
CARTSETMIRRORING_f((BAS_INT(585) * ((IOBYTE_Y / BAS_UBYTE(16u)) & BAS_UBYTE(1u))));
break;
case BAS_UBYTE(34u):;
#line 1744 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), IOBYTE_Y);
break;
case BAS_UBYTE(1u):;
#line 1753 "cpu.bas"
CONFIG_i = BAS_BYTE(0);
#line 1754 "cpu.bas"
if((IOBYTE_Y & BAS_UBYTE(128u))) {
#line 1755 "cpu.bas"
MAPREG_Y_a[BAS_BYTE(0)] = BAS_UBYTE(12u);
#line 1755 "cpu.bas"
CONFIG_i = BAS_UBYTE(1u);
} else {
#line 1757 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(5u)] |= ((IOBYTE_Y & BAS_UBYTE(1u)) << MAPREG_Y_a[BAS_UBYTE(4u)]);
#line 1758 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(4u)] += BAS_UBYTE(1u);
#line 1759 "cpu.bas"
CONFIG_i = ((MAPREG_Y_a[BAS_UBYTE(4u)] >= BAS_UBYTE(5u)) ? -1 : 0);
#line 1760 "cpu.bas"
if(CONFIG_i) {
#line 1760 "cpu.bas"
MAPREG_Y_a[((ADDR_i & BAS_INT(24576)) / BAS_INT(8192))] = MAPREG_Y_a[BAS_UBYTE(5u)];
}
}
#line 1762 "cpu.bas"
if(CONFIG_i) {
#line 1764 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(5u)] = BAS_BYTE(0);
#line 1765 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(4u)] = BAS_BYTE(0);
#line 1771 "cpu.bas"
switch((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(3u))) {
case BAS_BYTE(0):;
#line 1771 "cpu.bas"
CARTSETMIRRORING_f(BAS_BYTE(0));
break;
case BAS_UBYTE(1u):;
#line 1772 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(585));
break;
case BAS_UBYTE(2u):;
#line 1773 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(520));
break;
case BAS_UBYTE(3u):;
#line 1774 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(576));
break;
}
#line 1777 "cpu.bas"
if((MAPREG_Y_a[BAS_BYTE(0)] & BAS_UBYTE(16u))) {
#line 1777 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_BYTE(0), MAPREG_Y_a[BAS_UBYTE(1u)]);
#line 1778 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_UBYTE(16u), MAPREG_Y_a[BAS_UBYTE(2u)]);
} else {
#line 1780 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(32u), BAS_BYTE(0), (MAPREG_Y_a[BAS_UBYTE(1u)] / BAS_UBYTE(2u)));
}
#line 1783 "cpu.bas"
switch(((MAPREG_Y_a[BAS_BYTE(0)] / BAS_UBYTE(4u)) & BAS_UBYTE(3u))) {
case BAS_BYTE(0):;
case BAS_UBYTE(1u):;
#line 1784 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(128u), BAS_UBYTE(128u), ((MAPREG_Y_a[BAS_UBYTE(3u)] & BAS_UBYTE(14u)) / BAS_UBYTE(2u)));
break;
case BAS_UBYTE(2u):;
#line 1786 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), BAS_BYTE(0));
#line 1787 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), (MAPREG_Y_a[BAS_UBYTE(3u)] & BAS_UBYTE(15u)));
break;
case BAS_UBYTE(3u):;
#line 1789 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (MAPREG_Y_a[BAS_UBYTE(3u)] & BAS_UBYTE(15u)));
#line 1790 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(192u), BAS_BYTE(-1));
break;
}
}
break;
case BAS_UBYTE(9u):;
#line 1795 "cpu.bas"
switch(((ADDR_i & BAS_INT(28672)) / BAS_INT(4096))) {
case BAS_UBYTE(2u):;
#line 1795 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(32u), BAS_UBYTE(128u), (IOBYTE_Y & BAS_UBYTE(15u)));
break;
case BAS_UBYTE(3u):;
#line 1796 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(2u)] = IOBYTE_Y;
break;
case BAS_UBYTE(4u):;
#line 1797 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(3u)] = IOBYTE_Y;
break;
case BAS_UBYTE(5u):;
#line 1798 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(4u)] = IOBYTE_Y;
break;
case BAS_UBYTE(6u):;
#line 1799 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(5u)] = IOBYTE_Y;
break;
case BAS_UBYTE(7u):;
#line 1800 "cpu.bas"
if((IOBYTE_Y & BAS_UBYTE(1u))) {
#line 1800 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(576));
} else {
#line 1800 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(520));
}
break;
}
#line 1803 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_BYTE(0), MAPREG_Y_a[(BAS_UBYTE(2u) + MAPREG_Y_a[BAS_BYTE(0)])]);
#line 1804 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_UBYTE(16u), MAPREG_Y_a[(BAS_UBYTE(4u) + MAPREG_Y_a[BAS_UBYTE(1u)])]);
break;
case BAS_UBYTE(4u):;
#line 1820 "cpu.bas"
CONFIG_i = MAPREG_Y_a[BAS_UBYTE(8u)];
#line 1822 "cpu.bas"
switch(((ADDR_i & BAS_UBYTE(1u)) + ((ADDR_i & BAS_INT(24576)) / BAS_INT(4096)))) {
case BAS_BYTE(0):;
#line 1822 "cpu.bas"
CONFIG_i = IOBYTE_Y;
break;
case BAS_UBYTE(1u):;
#line 1823 "cpu.bas"
MAPREG_Y_a[(CONFIG_i & BAS_UBYTE(7u))] = IOBYTE_Y;
break;
case BAS_UBYTE(2u):;
#line 1825 "cpu.bas"
if((IOBYTE_Y & BAS_UBYTE(1u))) {
#line 1825 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(576));
} else {
#line 1825 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(520));
}
break;
case BAS_UBYTE(3u):;
break;
case BAS_UBYTE(4u):;
#line 1827 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(9u)] = IOBYTE_Y;
break;
case BAS_UBYTE(5u):;
#line 1828 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(10u)] = BAS_BYTE(0);
break;
case BAS_UBYTE(6u):;
#line 1829 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(11u)] = BAS_BYTE(0);
#line 1829 "cpu.bas"
CPU_u.IRQ_i &= BAS_UBYTE(254u);
break;
case BAS_UBYTE(7u):;
#line 1830 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(11u)] = BAS_UBYTE(1u);
break;
}
#line 1832 "cpu.bas"
A_Y = ((CONFIG_i & BAS_UBYTE(128u)) / BAS_UBYTE(8u));
#line 1833 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(8u), (BAS_BYTE(0) ^ A_Y), (MAPREG_Y_a[BAS_BYTE(0)] / BAS_UBYTE(2u)));
#line 1834 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(8u), (BAS_UBYTE(8u) ^ A_Y), (MAPREG_Y_a[BAS_UBYTE(1u)] / BAS_UBYTE(2u)));
#line 1835 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(4u), (BAS_UBYTE(16u) ^ A_Y), MAPREG_Y_a[BAS_UBYTE(2u)]);
#line 1836 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(4u), (BAS_UBYTE(20u) ^ A_Y), MAPREG_Y_a[BAS_UBYTE(3u)]);
#line 1837 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(4u), (BAS_UBYTE(24u) ^ A_Y), MAPREG_Y_a[BAS_UBYTE(4u)]);
#line 1838 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(4u), (BAS_UBYTE(28u) ^ A_Y), MAPREG_Y_a[BAS_UBYTE(5u)]);
#line 1839 "cpu.bas"
A_Y = (CONFIG_i & BAS_UBYTE(64u));
#line 1840 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(32u), (BAS_UBYTE(128u) ^ A_Y), MAPREG_Y_a[BAS_UBYTE(6u)]);
#line 1841 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(32u), BAS_UBYTE(160u), MAPREG_Y_a[BAS_UBYTE(7u)]);
#line 1842 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(32u), (BAS_UBYTE(192u) ^ A_Y), BAS_BYTE(-2));
#line 1843 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(8u)] = CONFIG_i;
break;
case BAS_UBYTE(10u):;
#line 1846 "cpu.bas"
switch(((ADDR_i & BAS_INT(28672)) / BAS_INT(4096))) {
case BAS_UBYTE(2u):;
#line 1846 "cpu.bas"
CARTSETPRG_f(BAS_UBYTE(64u), BAS_UBYTE(128u), (IOBYTE_Y & BAS_UBYTE(15u)));
break;
case BAS_UBYTE(3u):;
#line 1847 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(2u)] = IOBYTE_Y;
break;
case BAS_UBYTE(4u):;
#line 1848 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(3u)] = IOBYTE_Y;
break;
case BAS_UBYTE(5u):;
#line 1849 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(4u)] = IOBYTE_Y;
break;
case BAS_UBYTE(6u):;
#line 1850 "cpu.bas"
MAPREG_Y_a[BAS_UBYTE(5u)] = IOBYTE_Y;
break;
case BAS_UBYTE(7u):;
#line 1851 "cpu.bas"
if((IOBYTE_Y & BAS_UBYTE(1u))) {
#line 1851 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(576));
} else {
#line 1851 "cpu.bas"
CARTSETMIRRORING_f(BAS_INT(520));
}
break;
}
#line 1854 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_BYTE(0), MAPREG_Y_a[(BAS_UBYTE(2u) + MAPREG_Y_a[BAS_BYTE(0)])]);
#line 1855 "cpu.bas"
CARTSETCHR_f(BAS_UBYTE(16u), BAS_UBYTE(16u), MAPREG_Y_a[(BAS_UBYTE(4u) + MAPREG_Y_a[BAS_UBYTE(1u)])]);
break;
case BAS_UBYTE(5u):;
break;
}
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUTICKNOISE */
#line 1305 "cpu.bas"
BAS_INT APUTICKNOISE_f(BAS_INT CYCLESACCUMULATED_i)
{
BAS_INT FunctionReturn_i { };
#line 1306 "cpu.bas"
BAS_INT WL_i { };
#line 1306 "cpu.bas"
BAS_UBYTE BIT_Y { };
#line 1306 "cpu.bas"
BAS_UBYTE VOL_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1308 "cpu.bas"
VOL_Y = APUCHANNELS_u_a[BAS_UBYTE(3u)].LEVEL_Y;
#line 1309 "cpu.bas"
FunctionReturn_i = VOL_Y;
#line 1310 "cpu.bas"
if(((APU_u.CHANNELSENABLED_Y & BAS_INT(8)) == BAS_BYTE(0))) {
#line 1311 "cpu.bas"
goto subfunc_exit;
}
#line 1312 "cpu.bas"
WL_i = (APUNOISEPERIODS_i_a[APU_u.NOISEFREQ_Y] * TURBOFACTOR_z);
#line 1312 "cpu.bas"
if((WL_i == BAS_BYTE(0))) {
#line 1313 "cpu.bas"
WL_i = BAS_UBYTE(1u);
}
#line 1313 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(3u)].WAVECOUNTER_i -= CYCLESACCUMULATED_i;
#line 1314 "cpu.bas"
while((APUCHANNELS_u_a[BAS_UBYTE(3u)].WAVECOUNTER_i <= BAS_BYTE(0))) {
#line 1315 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(3u)].WAVECOUNTER_i += WL_i;
#line 1320 "cpu.bas"
if(APU_u.NOISETYPE_Y) {
#line 1321 "cpu.bas"
BIT_Y = (APU_u.NOISELFSR_i / BAS_UBYTE(64u));
} else {
#line 1323 "cpu.bas"
BIT_Y = (APU_u.NOISELFSR_i / BAS_UBYTE(2u));
}
#line 1325 "cpu.bas"
APU_u.NOISELFSR_i = ((APU_u.NOISELFSR_i / BAS_UBYTE(2u)) | (BAS_INT(16384) * ((APU_u.NOISELFSR_i ^ BIT_Y) & BAS_UBYTE(1u))));
}
#line 1329 "cpu.bas"
if((((APU_u.NOISELFSR_i & BAS_UBYTE(1u)) != BAS_BYTE(0)) || (APUCHANNELS_u_a[BAS_UBYTE(3u)].LENGTHCOUNTER_Y == BAS_BYTE(0)))) {
#line 1329 "cpu.bas"
VOL_Y = BAS_BYTE(0);
} else {
#line 1331 "cpu.bas"
VOL_Y = APUCHANNELS_u_a[BAS_UBYTE(3u)].ENVELOPE_Y;
}
#line 1333 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(3u)].LEVEL_Y = VOL_Y;
#line 1334 "cpu.bas"
FunctionReturn_i = VOL_Y;
 subfunc_exit:; 
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CARTSETCHR */
#line 1560 "cpu.bas"
void CARTSETCHR_f(BAS_UBYTE SIZE_Y, BAS_UBYTE BASEADDR_Y, BAS_INT INDEX_i)
{
#line 1562 "cpu.bas"
BAS_INT MATLOC_i { };
#line 1561 "cpu.bas"
BAS_INT B_i { };
#line 1561 "cpu.bas"
BAS_INT N_i { };
#line 1561 "cpu.bas"
BAS_INT V_i { };
#line 1561 "cpu.bas"
BAS_INT P_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 1562 "cpu.bas"
P_i = (BASEADDR_Y / BAS_INT(4));
#line 1563 "cpu.bas"
V_i = (CHRSIZEPAGES_i + (INDEX_i * SIZE_Y));
#line 1565 "cpu.bas"
while(((P_i < ((BASEADDR_Y + SIZE_Y) / BAS_INT(4))) && (P_i < BAS_INT(8)))) {
#line 1566 "cpu.bas"
V_i &= (CHRSIZEPAGES_i + BAS_BYTE(-1));
#line 1568 "cpu.bas"
if(BAS_INT(-1)) {
#line 1568 "cpu.bas"
CHRBANKS_l_a[P_i] = (
#line 1568 "cpu.bas"
(BAS_LNG)std::round(V_i) * 256u);
} else {
#line 1571 "cpu.bas"
if(((CHRBANKS_l_a[P_i] != V_i) && (CHRSIZEPAGES_i != BAS_BYTE(0)))) {
#line 1572 "cpu.bas"
CHRBANKS_l_a[P_i] = V_i;
#line 1572 "cpu.bas"
B_StmtGET(SWAPFILEHANDLE_l, ((SWAPCHRBASIS_l + (
#line 1572 "cpu.bas"
(BAS_LNG)std::round(V_i) * 16)) + BAS_BYTE(-1)));
#line 1575 "cpu.bas"
MATLOC_i = ((P_i * BAS_INT(1024)) & BAS_INT(8191));
#line 1577 "cpu.bas"
for(N_i = BAS_UBYTE(1u);N_i <= BAS_INT(64);N_i += BAS_BYTE(1)) {
#line 1577 "cpu.bas"
B_StmtGET(SWAPFILEHANDLE_l);
#line 1579 "cpu.bas"
for(B_i = BAS_UBYTE(1u);B_i <= BAS_UBYTE(16u);B_i += BAS_BYTE(1)) {
#line 1579 "cpu.bas"
CHRROM_Y_a.Index(0,0,MATLOC_i) = B_ASC_MID(BS_s, B_i);
#line 1580 "cpu.bas"
MATLOC_i += BAS_UBYTE(1u);
}
}
}
}
#line 1586 "cpu.bas"
P_i += BAS_UBYTE(1u);
#line 1587 "cpu.bas"
V_i += BAS_INT(4);
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB YUVTORGBPALETTED */
#line 2936 "cpu.bas"
BAS_INT YUVTORGBPALETTED_f(BAS_INT YIN_i, BAS_INT IIN_i, BAS_INT QIN_i, BAS_UBYTE BAYER_Y)
{
BAS_INT FunctionReturn_i { };
#line 2954 "cpu.bas"
BAS_INT YTMP_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2955 "cpu.bas"
YTMP_i = ((YIN_i * BAS_UBYTE(13u)) / BAS_UBYTE(75u));
#line 2957 "cpu.bas"
FunctionReturn_i = ((TRANSLATEREDBAYER_Y_a[(((YTMP_i + (IIN_i / BAS_UBYTE(83u))) + (QIN_i / BAS_UBYTE(127u))))-(-128)][BAYER_Y] + TRANSLATEGREENBAYER_Y_a[(((YTMP_i + (IIN_i / BAS_INT(-287))) + (QIN_i / BAS_BYTE(-124))))-(-128)][BAYER_Y]) + TRANSLATEBLUEBAYER_Y_a[(((YTMP_i + (IIN_i / BAS_BYTE(-71))) + (QIN_i / BAS_UBYTE(46u))))-(-128)][BAYER_Y]);
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUINCROAM2POS */
#line 2009 "cpu.bas"
void PPUINCROAM2POS_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2010 "cpu.bas"
PPU_u.OAM2POS_Y = ((PPU_u.OAM2POS_Y + BAS_UBYTE(1u)) & BAS_UBYTE(31u));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CARTSETMIRRORING */
#line 1514 "cpu.bas"
void CARTSETMIRRORING_f(BAS_INT MODE_i)
{
B_ERR_FRAME_SUB_BEGIN();
#line 1515 "cpu.bas"
NTA_i_a[BAS_BYTE(0)] = ((MODE_i & BAS_UBYTE(7u)) * BAS_INT(1024));
#line 1516 "cpu.bas"
NTA_i_a[BAS_UBYTE(1u)] = (((MODE_i / BAS_UBYTE(8u)) & BAS_UBYTE(7u)) * BAS_INT(1024));
#line 1517 "cpu.bas"
NTA_i_a[BAS_UBYTE(2u)] = (((MODE_i / BAS_UBYTE(64u)) & BAS_UBYTE(7u)) * BAS_INT(1024));
#line 1518 "cpu.bas"
NTA_i_a[BAS_UBYTE(3u)] = (((MODE_i / BAS_INT(512)) & BAS_UBYTE(7u)) * BAS_INT(1024));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB TELEVISIONDECODE */
#line 2726 "cpu.bas"
void TELEVISIONDECODE_f(BAS_BYTE LEVEL_y)
{
#line 2743 "cpu.bas"
BAS_INT XX_i { };
#line 2732 "cpu.bas"
static BAS_INT CURY_i { };
#line 2732 "cpu.bas"
static BAS_INT PIXELCARRY_i { };
#line 2732 "cpu.bas"
static BAS_INT CURX_i { };
#line 2731 "cpu.bas"
static BAS_INT SUMI_i { };
#line 2744 "cpu.bas"
BAS_INT YY_i { };
#line 2731 "cpu.bas"
static BAS_INT SUMQ_i { };
#line 2731 "cpu.bas"
static BAS_INT SUMY_i { };
#line 2727 "cpu.bas"
static BAS_INT WAITING_i { };
#line 2727 "cpu.bas"
static BAS_INT SYNCLENGTH_i { };
#line 2840 "cpu.bas"
BAS_BYTE SPOT1_y { };
#line 2840 "cpu.bas"
BAS_BYTE OLDSPOT1_y { };
#line 2729 "cpu.bas"
static BAS_BYTE DECODEPHASEY_y { };
#line 2728 "cpu.bas"
static BAS_BYTE COLORPHASE_y { };
#line 2840 "cpu.bas"
BAS_BYTE SPOT2_y { };
#line 2728 "cpu.bas"
static BAS_BYTE DECODEPHASE_y { };
#line 2840 "cpu.bas"
BAS_BYTE OLDSPOT2_y { };
#line 2729 "cpu.bas"
static BAS_BYTE DECODEPHASEI_y { };
#line 2727 "cpu.bas"
static BAS_BYTE PREVIOUS_y { };
#line 2741 "cpu.bas"
static BAS_UBYTE COUNTER_Y { };
#line 2730 "cpu.bas"
static BAS_UBYTE PHASE2_Y { };
// Automatically added temporaries:
BAS_INT selv1_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2741 "cpu.bas"
if(BAS_INT(0)) {
#line 2743 "cpu.bas"
if(((COUNTER_Y & BAS_UBYTE(1u)) == BAS_BYTE(0))) {
#line 2744 "cpu.bas"
XX_i = ((PPU_u.COLUMN_i * BAS_UBYTE(4u)) + (COUNTER_Y / BAS_UBYTE(2u)));
#line 2745 "cpu.bas"
YY_i = (PPU_u.ROW_i * BAS_UBYTE(2u));
#line 2746 "cpu.bas"
B_StmtPSET(BAS_UBYTE(0u), XX_i, (YY_i + BAS_BYTE(0)), (65793 * ((BAS_UBYTE(255u) * LEVEL_y) / BAS_UBYTE(125u))));
#line 2747 "cpu.bas"
B_StmtPSET(BAS_UBYTE(0u), XX_i, (YY_i + BAS_UBYTE(1u)), (65793 * ((BAS_UBYTE(255u) * LEVEL_y) / BAS_UBYTE(125u))));
}
#line 2749 "cpu.bas"
COUNTER_Y = ((COUNTER_Y + BAS_UBYTE(1u)) & BAS_UBYTE(7u));
#line 2751 "cpu.bas"
goto subfunc_exit;
}
#line 2753 "cpu.bas"
DECODEPHASE_y += BAS_BYTE(-1);
#line 2753 "cpu.bas"
if((DECODEPHASE_y < BAS_BYTE(0))) {
#line 2753 "cpu.bas"
DECODEPHASE_y = BAS_INT(23);
}
#line 2754 "cpu.bas"
DECODEPHASEY_y += BAS_BYTE(-1);
#line 2754 "cpu.bas"
if((DECODEPHASEY_y < BAS_BYTE(0))) {
#line 2754 "cpu.bas"
DECODEPHASEY_y = BAS_INT(23);
}
#line 2755 "cpu.bas"
DECODEPHASEI_y += BAS_BYTE(-1);
#line 2755 "cpu.bas"
if((DECODEPHASEI_y < BAS_BYTE(0))) {
#line 2755 "cpu.bas"
DECODEPHASEI_y = BAS_INT(23);
}
#line 2757 "cpu.bas"
if((LEVEL_y < BAS_UBYTE(10u))) {
#line 2758 "cpu.bas"
switch(SYNCLENGTH_i) {
case BAS_UBYTE(30u):;
#line 2762 "cpu.bas"
if((WAITING_i == BAS_BYTE(0))) {
#line 2764 "cpu.bas"
if((BAS_INT(0) && (CURY_i < BAS_UBYTE(240u)))) {
#line 2766 "cpu.bas"
WAITING_i = (CURY_i * BAS_UBYTE(80u));
#line 2767 "cpu.bas"
B_StmtDEFSEG(BAS_UINT(40960u));
#line 2768 "cpu.bas"
for(PHASE2_Y = BAS_BYTE(0);PHASE2_Y < BAS_INT(4);PHASE2_Y += BAS_BYTE(1)) {
#line 2769 "cpu.bas"
B_StmtOUT(BAS_INT(964), BAS_UBYTE(2u));
#line 2769 "cpu.bas"
B_StmtOUT(BAS_INT(965), (BAS_UBYTE(1u) << PHASE2_Y));
#line 2770 "cpu.bas"
SUMY_i = PHASE2_Y;
#line 2772 "cpu.bas"
for(CURX_i = BAS_BYTE(0);CURX_i < BAS_INT(80);CURX_i += BAS_BYTE(1)) {
#line 2772 "cpu.bas"
B_StmtPOKE((WAITING_i + CURX_i), MODE13PIXELS_Y_a[SUMY_i]);
#line 2773 "cpu.bas"
SUMY_i += BAS_UBYTE(4u);
}
}
}
#line 2777 "cpu.bas"
CURY_i += BAS_UBYTE(1u);
#line 2778 "cpu.bas"
WAITING_i = BAS_BYTE(-1);
#line 2779 "cpu.bas"
PIXELCARRY_i = BAS_BYTE(0);
#line 2780 "cpu.bas"
CURX_i = BAS_BYTE(0);
}
#line 2782 "cpu.bas"
SYNCLENGTH_i += BAS_UBYTE(1u);
break;
case BAS_INT(1000):;
#line 2785 "cpu.bas"
CURY_i = BAS_BYTE(0);
break;
default:;
#line 2790 "cpu.bas"
SYNCLENGTH_i += BAS_UBYTE(1u);
}
#line 2794 "cpu.bas"
goto subfunc_exit;
}
#line 2797 "cpu.bas"
if((SYNCLENGTH_i > BAS_BYTE(0))) {
#line 2797 "cpu.bas"
SYNCLENGTH_i += BAS_BYTE(-1);
}
#line 2804 "cpu.bas"
selv1_i = WAITING_i; if(selv1_i < BAS_BYTE(0)) {
#line 2805 "cpu.bas"
if((LEVEL_y >= BAS_UBYTE(64u))) {
#line 2807 "cpu.bas"
WAITING_i -= BAS_UBYTE(1u);
#line 2810 "cpu.bas"
if((WAITING_i <= BAS_BYTE(-6))) {
#line 2810 "cpu.bas"
WAITING_i = BAS_UBYTE(3u);
#line 2811 "cpu.bas"
DECODEPHASE_y = (((DECODEPHASE_y + BAS_UBYTE(24u)) - COLORPHASE_y) % BAS_UBYTE(12u));
#line 2812 "cpu.bas"
DECODEPHASEY_y = (((DECODEPHASE_y + BAS_UBYTE(24u)) - BAS_UBYTE(12u)) % BAS_UBYTE(24u));
#line 2813 "cpu.bas"
DECODEPHASEI_y = (((DECODEPHASE_y + BAS_UBYTE(24u)) - BAS_BYTE(0)) % BAS_UBYTE(24u));
#line 2814 "cpu.bas"
SUMY_i = BAS_BYTE(0);
#line 2815 "cpu.bas"
SUMI_i = BAS_BYTE(0);
#line 2816 "cpu.bas"
SUMQ_i = BAS_BYTE(0);
}
} else {
#line 2821 "cpu.bas"
if(((LEVEL_y >= BAS_UBYTE(32u)) && (PREVIOUS_y < BAS_UBYTE(32u)))) {
#line 2827 "cpu.bas"
COLORPHASE_y = PHASE2_Y;
#line 2827 "cpu.bas"
PHASE2_Y = DECODEPHASE_y;
}
#line 2829 "cpu.bas"
PREVIOUS_y = LEVEL_y;
}
} else if(selv1_i > BAS_BYTE(0)) {
#line 2832 "cpu.bas"
WAITING_i += BAS_BYTE(-1);
} else {
#line 2842 "cpu.bas"
OLDSPOT1_y = SIGNALHISTORY_y_a[DECODEPHASEY_y];
#line 2843 "cpu.bas"
OLDSPOT2_y = SIGNALHISTORY_y_a[DECODEPHASEI_y];
#line 2844 "cpu.bas"
SIGNALHISTORY_y_a[DECODEPHASE_y] = LEVEL_y;
#line 2846 "cpu.bas"
SPOT1_y = (LEVEL_y - OLDSPOT1_y);
#line 2847 "cpu.bas"
SPOT2_y = (LEVEL_y - OLDSPOT2_y);
#line 2849 "cpu.bas"
SUMY_i += SPOT1_y;
#line 2850 "cpu.bas"
SUMI_i += (SPOT2_y * SCALEDSINE_i_a[(DECODEPHASE_y + BAS_UBYTE(3u))]);
#line 2851 "cpu.bas"
SUMQ_i += (SPOT2_y * SCALEDSINE_i_a[(DECODEPHASE_y + BAS_BYTE(0))]);
#line 2853 "cpu.bas"
PIXELCARRY_i += BAS_INT(640);
#line 2854 "cpu.bas"
if((PIXELCARRY_i >= BAS_INT(2262))) {
#line 2855 "cpu.bas"
PIXELCARRY_i -= BAS_INT(2262);
#line 2856 "cpu.bas"
if(((CURX_i < BAS_INT(640)) && ((CURY_i * BAS_UBYTE(2u)) < BAS_INT(484)))) {
#line 2858 "cpu.bas"
if(BAS_INT(0)) {
#line 2878 "cpu.bas"
XX_i = (CURX_i & BAS_UBYTE(1u));
#line 2879 "cpu.bas"
YY_i = (CURY_i & BAS_UBYTE(1u));
#line 2880 "cpu.bas"
MODE13PIXELS_Y_a[CURX_i] = YUVTORGBPALETTED_f(SUMY_i, SUMI_i, SUMQ_i, ((XX_i * BAS_UBYTE(2u)) ^ ((YY_i * BAS_UBYTE(2u)) + YY_i)));
} else {
#line 2882 "cpu.bas"
XX_i = SUMY_i;
#line 2883 "cpu.bas"
for(YY_i = BAS_UBYTE(1u);YY_i <= BAS_UBYTE(2u);YY_i += BAS_BYTE(1)) {
#line 2884 "cpu.bas"
B_StmtPSET(BAS_UBYTE(0u), CURX_i, (((CURY_i * BAS_UBYTE(2u)) + YY_i) + BAS_BYTE(-1)), YUVTORGB_f(XX_i, SUMI_i, SUMQ_i));
#line 2885 "cpu.bas"
XX_i -= (XX_i / BAS_UBYTE(10u));
}
}
#line 2888 "cpu.bas"
CURX_i += BAS_UBYTE(1u);
}
}
} 
 subfunc_exit:; 
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB DISASSEMBLYTRACE */
#line 1911 "cpu.bas"
void DISASSEMBLYTRACE_f(BAS_INT WHERE_i, BAS_INT OP_i)
{
#line 1912 "cpu.bas"
std::string M_s { };
#line 1912 "cpu.bas"
std::string S_s { };
#line 1912 "cpu.bas"
std::string L_s { };
#line 1912 "cpu.bas"
std::string E_s { };
#line 1912 "cpu.bas"
std::string B_s { };
#line 1914 "cpu.bas"
BAS_INT A_i { };
#line 1914 "cpu.bas"
BAS_INT DUMPADDR_i { };
#line 1913 "cpu.bas"
BAS_INT O_i { };
#line 1914 "cpu.bas"
BAS_BYTE N_y { };
#line 1913 "cpu.bas"
BAS_UINT T_I { };
#line 1913 "cpu.bas"
BAS_UBYTE D_Y { };
// Automatically added temporaries:
BAS_INT fend4_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 1916 "cpu.bas"
if((OP_i < BAS_BYTE(0))) {
#line 1916 "cpu.bas"
if((OP_i == BAS_UBYTE(76u))) {
#line 1916 "cpu.bas"
S_s = "Resetting CPU";
}
#line 1917 "cpu.bas"
if((OP_i == BAS_UBYTE(77u))) {
#line 1917 "cpu.bas"
S_s = "Firing NMI";
}
#line 1918 "cpu.bas"
if((OP_i == BAS_UBYTE(78u))) {
#line 1918 "cpu.bas"
S_s = "Firing IRQ";
}
#line 1920 "cpu.bas"
D_Y = BAS_UBYTE(10u);
} else {
#line 1921 "cpu.bas"
D_Y = CPUMODES_y_a[OP_i];
#line 1922 "cpu.bas"
O_i = CPUOPS_y_a[OP_i];
#line 1923 "cpu.bas"
S_s = 
#line 1923 "cpu.bas"
B_FuncMID_S(OPCODENAMES_s, ((O_i * BAS_UBYTE(3u)) + BAS_UBYTE(1u)), BAS_UBYTE(3u));
}
#line 1925 "cpu.bas"
if((D_Y == BAS_UBYTE(8u))) {
#line 1925 "cpu.bas"
D_Y = BAS_UBYTE(14u);
#line 1925 "cpu.bas"
if((S_s.compare(0, std::string::npos, "SAX", 3)==0)) {
#line 1926 "cpu.bas"
S_s = "SHA";
}
}
#line 1926 "cpu.bas"
if((D_Y == BAS_UBYTE(15u))) {
#line 1926 "cpu.bas"
D_Y = BAS_UBYTE(16u);
#line 1926 "cpu.bas"
S_s = "SHA";
}
#line 1927 "cpu.bas"
if((D_Y == BAS_UBYTE(7u))) {
#line 1927 "cpu.bas"
D_Y = BAS_UBYTE(4u);
#line 1927 "cpu.bas"
S_s = "SHY";
}
#line 1928 "cpu.bas"
if((D_Y == BAS_UBYTE(9u))) {
#line 1928 "cpu.bas"
D_Y = BAS_UBYTE(14u);
#line 1928 "cpu.bas"
S_s = "SHX";
}
#line 1929 "cpu.bas"
if((S_s.compare(0, std::string::npos, "JMI", 3)==0)) {
#line 1929 "cpu.bas"
S_s = "JMP";
#line 1930 "cpu.bas"
D_Y = BAS_UBYTE(19u);
}
#line 1930 "cpu.bas"
if((S_s.compare(0, std::string::npos, "JSR", 3)==0)) {
#line 1931 "cpu.bas"
D_Y = BAS_UBYTE(1u);
}
#line 1931 "cpu.bas"
if(((S_s.compare(0, std::string::npos, "RTS", 3)==0) || (S_s.compare(0, std::string::npos, "RTI", 3)==0))) {
#line 1932 "cpu.bas"
D_Y = BAS_UBYTE(10u);
}
#line 1932 "cpu.bas"
if((S_s.compare(0, std::string::npos, "BRK", 3)==0)) {
#line 1934 "cpu.bas"
D_Y = BAS_UBYTE(11u);
}
#line 1935 "cpu.bas"
switch(D_Y) {
case BAS_UBYTE(11u):;
#line 1935 "cpu.bas"
N_y = BAS_UBYTE(1u);
#line 1936 "cpu.bas"
B_s = "#$";
break;
case BAS_UBYTE(12u):;
#line 1936 "cpu.bas"
N_y = BAS_BYTE(-1);
#line 1937 "cpu.bas"
B_s = "$";
break;
case BAS_BYTE(0):;
#line 1937 "cpu.bas"
N_y = BAS_UBYTE(1u);
#line 1938 "cpu.bas"
B_s = "$";
break;
case BAS_UBYTE(2u):;
#line 1938 "cpu.bas"
N_y = BAS_UBYTE(1u);
#line 1938 "cpu.bas"
B_s = "$";
#line 1939 "cpu.bas"
E_s = ",X";
break;
case BAS_UBYTE(5u):;
#line 1939 "cpu.bas"
N_y = BAS_UBYTE(1u);
#line 1939 "cpu.bas"
B_s = "$";
#line 1940 "cpu.bas"
E_s = ",Y";
break;
case BAS_UBYTE(13u):;
#line 1940 "cpu.bas"
N_y = BAS_UBYTE(1u);
#line 1940 "cpu.bas"
B_s = "($";
#line 1941 "cpu.bas"
E_s = ",X)";
break;
case BAS_UBYTE(16u):;
case BAS_UBYTE(17u):;
#line 1941 "cpu.bas"
N_y = BAS_UBYTE(1u);
#line 1941 "cpu.bas"
B_s = "($";
#line 1942 "cpu.bas"
E_s = "),Y";
break;
case BAS_UBYTE(1u):;
#line 1942 "cpu.bas"
N_y = BAS_UBYTE(2u);
#line 1943 "cpu.bas"
B_s = "$";
break;
case BAS_UBYTE(4u):;
case BAS_UBYTE(3u):;
#line 1943 "cpu.bas"
N_y = BAS_UBYTE(2u);
#line 1943 "cpu.bas"
B_s = "$";
#line 1944 "cpu.bas"
E_s = ",X";
break;
case BAS_UBYTE(14u):;
case BAS_UBYTE(6u):;
#line 1944 "cpu.bas"
N_y = BAS_UBYTE(2u);
#line 1944 "cpu.bas"
B_s = "$";
#line 1945 "cpu.bas"
E_s = ",Y";
break;
case BAS_UBYTE(19u):;
#line 1945 "cpu.bas"
N_y = BAS_UBYTE(2u);
#line 1945 "cpu.bas"
B_s = "($";
#line 1946 "cpu.bas"
E_s = ")";
break;
}
#line 1948 "cpu.bas"
M_s = "";
#line 1950 "cpu.bas"
fend4_i = (BAS_UBYTE(std::labs(N_y)) + BAS_UBYTE(1u)); for(A_i = BAS_BYTE(0);A_i < fend4_i;A_i += BAS_BYTE(1)) {
#line 1950 "cpu.bas"
DUMPADDR_i = (WHERE_i + A_i);
#line 1951 "cpu.bas"
if(((DUMPADDR_i >= BAS_BYTE(0)) && (DUMPADDR_i < BAS_INT(8192)))) {
#line 1952 "cpu.bas"
T_I = RAM_Y_a[(DUMPADDR_i & BAS_INT(2047))];
} else {
#line 1954 "cpu.bas"
DUMPADDR_i &= BAS_INT(32767);
#line 1955 "cpu.bas"
if(BAS_BYTE(0)) {
#line 1956 "cpu.bas"
B_StmtDEFSEG(
#line 1956 "cpu.bas"
B_FuncVARSEG(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))));
#line 1957 "cpu.bas"
T_I = 
#line 1957 "cpu.bas"
B_FuncPEEK((
#line 1957 "cpu.bas"
B_FuncVARPTR(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))) + (DUMPADDR_i & BAS_INT(32767))));
} else {
#line 1959 "cpu.bas"
T_I = PRGROM_Y_a.Index(0,0,(PRGBANKS_l_a[(DUMPADDR_i / BAS_INT(8192))] + (DUMPADDR_i & BAS_INT(8191))));
}
}
#line 1962 "cpu.bas"
if(BAS_BYTE(0)) {
#line 1962 "cpu.bas"
M_s = ((M_s + HEXS_f(T_I, BAS_UBYTE(2u))) + " ");
} else {
#line 1962 "cpu.bas"
M_s += HEXS_f(T_I, BAS_UBYTE(2u));
}
}
#line 1964 "cpu.bas"
if(BAS_INT(-1)) {
#line 1964 "cpu.bas"
L_s = "        ";
#line 1964 "cpu.bas"
B_StmtLSET(L_s, M_s);
#line 1964 "cpu.bas"
L_s = (("|" + L_s) + "|");
}
#line 1968 "cpu.bas"
L_s = (((L_s + S_s) + " ") + B_s);
#line 1969 "cpu.bas"
for(A_i = BAS_UBYTE(std::labs(N_y));A_i >= BAS_UBYTE(1u);A_i += BAS_BYTE(-1)) {
#line 1970 "cpu.bas"
DUMPADDR_i = (WHERE_i + A_i);
#line 1971 "cpu.bas"
if(((DUMPADDR_i >= BAS_BYTE(0)) && (DUMPADDR_i < BAS_INT(8192)))) {
#line 1972 "cpu.bas"
T_I = RAM_Y_a[(DUMPADDR_i & BAS_INT(2047))];
} else {
#line 1974 "cpu.bas"
DUMPADDR_i &= BAS_INT(32767);
#line 1975 "cpu.bas"
if(BAS_BYTE(0)) {
#line 1976 "cpu.bas"
B_StmtDEFSEG(
#line 1976 "cpu.bas"
B_FuncVARSEG(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))));
#line 1977 "cpu.bas"
T_I = 
#line 1977 "cpu.bas"
B_FuncPEEK((
#line 1977 "cpu.bas"
B_FuncVARPTR(PRGROM_Y_a.Index(0,0,BAS_BYTE(0))) + (DUMPADDR_i & BAS_INT(32767))));
} else {
#line 1979 "cpu.bas"
T_I = PRGROM_Y_a.Index(0,0,(PRGBANKS_l_a[(DUMPADDR_i / BAS_INT(8192))] + (DUMPADDR_i & BAS_INT(8191))));
}
}
#line 1982 "cpu.bas"
if((N_y < BAS_BYTE(0))) {
#line 1983 "cpu.bas"
T_I = (((DUMPADDR_i + BAS_UBYTE(1u)) + (T_I & BAS_UBYTE(127u))) - (T_I & BAS_UBYTE(128u)));
#line 1984 "cpu.bas"
L_s += HEXS_f(T_I, BAS_UBYTE(4u));
} else {
#line 1986 "cpu.bas"
L_s += HEXS_f(T_I, BAS_UBYTE(2u));
}
}
#line 1989 "cpu.bas"
L_s += E_s;
#line 1992 "cpu.bas"
if(BAS_INT(-1)) {
#line 1992 "cpu.bas"
UsingFormatter ("\\  \\ A=\\\\ X=\\\\ Y=\\\\ P=\\\\ S=\\\\ Row ### Col ### &").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f((
#line 1993 "cpu.bas"
(BAS_LNG)std::round(WHERE_i) & 65535), BAS_UBYTE(4u)), HEXS_f(CPU_u.A_Y, BAS_UBYTE(2u)), HEXS_f(CPU_u.X_Y, BAS_UBYTE(2u)), HEXS_f(CPU_u.Y_Y, BAS_UBYTE(2u)), HEXS_f(FLAGS_f(), BAS_UBYTE(2u)), HEXS_f(CPU_u.S_Y, BAS_UBYTE(2u)), PPU_u.ROW_i, PPU_u.COLUMN_i, L_s) << PrintCRLFtag{}; 
} else {
#line 1996 "cpu.bas"
A_i = PPU_u.ROW_i;
#line 1996 "cpu.bas"
if((A_i == BAS_INT(261))) {
#line 1997 "cpu.bas"
A_i = BAS_BYTE(-1);
}
#line 1997 "cpu.bas"
UsingFormatter ("\\  \\  \\        \\\\                              \\A:\\\\ X:\\\\ Y:\\\\ P"
":\\\\ SP:\\\\ CYC:### SL:&").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), HEXS_f((
#line 1998 "cpu.bas"
(BAS_LNG)std::round(WHERE_i) & 65535), BAS_UBYTE(4u)), M_s, L_s, HEXS_f(CPU_u.A_Y, BAS_UBYTE(2u)), HEXS_f(CPU_u.X_Y, BAS_UBYTE(2u)), HEXS_f(CPU_u.Y_Y, BAS_UBYTE(2u)), HEXS_f((FLAGS_f() | BAS_UBYTE(32u)), BAS_UBYTE(2u)), HEXS_f(CPU_u.S_Y, BAS_UBYTE(2u)), PPU_u.COLUMN_i, 
#line 1999 "cpu.bas"
B_FuncLTRIM_S(
#line 2000 "cpu.bas"
B_FuncSTR_S(A_i))) << PrintCRLFtag{}; 
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB YUVTORGB */
#line 2903 "cpu.bas"
BAS_LNG YUVTORGB_f(BAS_INT YIN_i, BAS_INT IIN_i, BAS_INT QIN_i)
{
BAS_LNG FunctionReturn_l { };
#line 2924 "cpu.bas"
BAS_INT YTMP_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2925 "cpu.bas"
YTMP_i = ((YIN_i * BAS_UBYTE(13u)) / BAS_UBYTE(75u));
#line 2931 "cpu.bas"
FunctionReturn_l = (((TRANSLATECOLOR_Y_a[(((YTMP_i + (IIN_i / BAS_UBYTE(83u))) + (QIN_i / BAS_UBYTE(127u))))-(-128)] * 65536u) + (TRANSLATECOLOR_Y_a[(((YTMP_i + (IIN_i / BAS_INT(-287))) + (QIN_i / BAS_BYTE(-124))))-(-128)] * 256u)) + TRANSLATECOLOR_Y_a[(((YTMP_i + (IIN_i / BAS_BYTE(-71))) + (QIN_i / BAS_UBYTE(46u))))-(-128)]);
    return FunctionReturn_l;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUTICKTRIANGLE */
#line 1284 "cpu.bas"
BAS_INT APUTICKTRIANGLE_f(BAS_INT CYCLESACCUMULATED_i)
{
BAS_INT FunctionReturn_i { };
#line 1285 "cpu.bas"
BAS_INT WL_i { };
#line 1285 "cpu.bas"
BAS_UBYTE VOL_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 1287 "cpu.bas"
VOL_Y = APUCHANNELS_u_a[BAS_UBYTE(2u)].LEVEL_Y;
#line 1288 "cpu.bas"
FunctionReturn_i = VOL_Y;
#line 1289 "cpu.bas"
if(((APU_u.CHANNELSENABLED_Y & BAS_INT(4)) == BAS_BYTE(0))) {
#line 1290 "cpu.bas"
goto subfunc_exit;
}
#line 1291 "cpu.bas"
WL_i = ((APUCHANNELS_u_a[BAS_UBYTE(2u)].WAVELENGTH_i * TURBOFACTOR_z) + BAS_UBYTE(1u));
#line 1292 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(2u)].WAVECOUNTER_i -= CYCLESACCUMULATED_i;
#line 1293 "cpu.bas"
while((APUCHANNELS_u_a[BAS_UBYTE(2u)].WAVECOUNTER_i <= BAS_BYTE(0))) {
#line 1294 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(2u)].WAVECOUNTER_i += WL_i;
#line 1296 "cpu.bas"
if((((APUCHANNELS_u_a[BAS_UBYTE(2u)].LENGTHCOUNTER_Y != BAS_BYTE(0)) && (APU_u.LINEARCOUNTER_Y != BAS_BYTE(0))) && (WL_i >= BAS_UBYTE(3u)))) {
#line 1296 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(2u)].PHASE_Y += BAS_UBYTE(1u);
}
#line 1298 "cpu.bas"
VOL_Y = (APUCHANNELS_u_a[BAS_UBYTE(2u)].PHASE_Y & BAS_UBYTE(15u));
#line 1299 "cpu.bas"
if((APUCHANNELS_u_a[BAS_UBYTE(2u)].PHASE_Y & BAS_UBYTE(16u))) {
#line 1299 "cpu.bas"
VOL_Y ^= BAS_UBYTE(15u);
}
}
#line 1301 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(2u)].LEVEL_Y = VOL_Y;
#line 1302 "cpu.bas"
FunctionReturn_i = VOL_Y;
 subfunc_exit:; 
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB APUTICKDPCM */
#line 1337 "cpu.bas"
BAS_INT APUTICKDPCM_f(BAS_INT CYCLESACCUMULATED_i, BAS_INT W_i)
{
BAS_INT FunctionReturn_i { };
#line 1358 "cpu.bas"
BAS_INT OLDADDR_i { };
#line 1338 "cpu.bas"
BAS_INT WL_i { };
#line 1338 "cpu.bas"
BAS_INT VOL_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 1341 "cpu.bas"
VOL_i = APUCHANNELS_u_a[BAS_UBYTE(4u)].LEVEL_Y;
#line 1342 "cpu.bas"
FunctionReturn_i = VOL_i;
#line 1343 "cpu.bas"
if(((APU_u.CHANNELSENABLED_Y & BAS_INT(8)) == BAS_BYTE(0))) {
#line 1344 "cpu.bas"
goto subfunc_exit;
}
#line 1345 "cpu.bas"
WL_i = (APUCHANNELS_u_a[BAS_UBYTE(4u)].WAVELENGTH_i * TURBOFACTOR_z);
#line 1347 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].WAVECOUNTER_i -= CYCLESACCUMULATED_i;
#line 1348 "cpu.bas"
while((APUCHANNELS_u_a[BAS_UBYTE(4u)].WAVECOUNTER_i <= BAS_BYTE(0))) {
#line 1349 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].WAVECOUNTER_i += WL_i;
#line 1350 "cpu.bas"
if((WL_i == BAS_BYTE(0))) {
#line 1351 "cpu.bas"
goto do_exit0;
}
#line 1353 "cpu.bas"
if((APUCHANNELS_u_a[BAS_UBYTE(4u)].PHASE_Y == BAS_BYTE(0))) {
#line 1354 "cpu.bas"
if(((APUCHANNELS_u_a[BAS_UBYTE(4u)].LENGTHCOUNTER_Y == BAS_BYTE(0)) && (APU_u.LOOPENABLED_Y != BAS_BYTE(0)))) {
#line 1354 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].LENGTHCOUNTER_Y = APU_u.PCMLENGTH_i;
#line 1355 "cpu.bas"
APU_u.ADDRESS_i = APU_u.ADDRESSINIT_i;
}
#line 1357 "cpu.bas"
if((APUCHANNELS_u_a[BAS_UBYTE(4u)].LENGTHCOUNTER_Y > BAS_BYTE(0))) {
#line 1359 "cpu.bas"
OLDADDR_i = ADDR_i;
#line 1360 "cpu.bas"
CPU_u.DMCDELAY_Y = (BAS_UBYTE(3u) + W_i);
#line 1361 "cpu.bas"
ADDR_i = (APU_u.ADDRESS_i | BAS_UINT(32768u));
#line 1362 "cpu.bas"
APU_u.ADDRESS_i += BAS_UBYTE(1u);
#line 1363 "cpu.bas"
APU_u.PCMBYTE_Y = RB_f();
#line 1364 "cpu.bas"
ADDR_i = OLDADDR_i;
#line 1367 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].PHASE_Y = BAS_UBYTE(128u);
#line 1368 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].LENGTHCOUNTER_Y += BAS_BYTE(-1);
} else {
#line 1370 "cpu.bas"
if(APU_u.IRQENABLE_Y) {
#line 1370 "cpu.bas"
CPU_u.IRQ_i |= BAS_UBYTE(128u);
}
#line 1371 "cpu.bas"
APU_u.CHANNELSENABLED_Y &= BAS_BYTE(-17);
}
}
#line 1376 "cpu.bas"
if((APUCHANNELS_u_a[BAS_UBYTE(4u)].PHASE_Y != BAS_BYTE(0))) {
#line 1376 "cpu.bas"
if((APU_u.PCMBYTE_Y & APUCHANNELS_u_a[BAS_UBYTE(4u)].PHASE_Y)) {
#line 1376 "cpu.bas"
VOL_i += BAS_UBYTE(2u);
} else {
#line 1376 "cpu.bas"
VOL_i += BAS_BYTE(-2);
}
#line 1377 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].PHASE_Y = (APUCHANNELS_u_a[BAS_UBYTE(4u)].PHASE_Y / BAS_UBYTE(2u));
#line 1378 "cpu.bas"
if((VOL_i < BAS_BYTE(0))) {
#line 1378 "cpu.bas"
VOL_i = BAS_BYTE(0);
} else {
#line 1378 "cpu.bas"
if((VOL_i > BAS_UBYTE(127u))) {
#line 1378 "cpu.bas"
VOL_i = BAS_UBYTE(127u);
}
}
}
} do_exit0:;
#line 1381 "cpu.bas"
APUCHANNELS_u_a[BAS_UBYTE(4u)].LEVEL_Y = VOL_i;
#line 1382 "cpu.bas"
FunctionReturn_i = VOL_i;
 subfunc_exit:; 
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUINCROAMPOSLO */
#line 2003 "cpu.bas"
void PPUINCROAMPOSLO_f()
{
B_ERR_FRAME_SUB_BEGIN();
#line 2004 "cpu.bas"
PPU_u.OAMPOSLO_Y = ((PPU_u.OAMPOSLO_Y + BAS_UBYTE(1u)) & BAS_UBYTE(3u));
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUGETOAMPOS */
#line 2017 "cpu.bas"
BAS_INT PPUGETOAMPOS_f()
{
BAS_INT FunctionReturn_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2018 "cpu.bas"
FunctionReturn_i = (PPU_u.OAMPOSHI_Y + PPU_u.OAMPOSLO_Y);
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB CPUEXECUTE */
#line 549 "cpu.bas"
void CPUEXECUTE_f(BAS_UBYTE MODE_Y, BAS_INT OP_i)
{
#line 553 "cpu.bas"
BAS_INT F_i { };
#line 553 "cpu.bas"
BAS_INT T_i { };
#line 552 "cpu.bas"
BAS_BYTE UBC_y { };
#line 552 "cpu.bas"
BAS_BYTE LBC_y { };
#line 552 "cpu.bas"
BAS_BYTE UDC_y { };
#line 685 "cpu.bas"
BAS_BYTE BYTETEMP_y { };
#line 552 "cpu.bas"
BAS_BYTE LDC_y { };
#line 551 "cpu.bas"
BAS_UBYTE S_Y { };
#line 550 "cpu.bas"
BAS_UBYTE D_Y { };
#line 550 "cpu.bas"
BAS_UBYTE I2_Y { };
#line 551 "cpu.bas"
BAS_UBYTE L_Y { };
#line 550 "cpu.bas"
BAS_UBYTE I1_Y { };
B_ERR_FRAME_SUB_BEGIN();
#line 589 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 590 "cpu.bas"
switch(MODE_Y) {
case BAS_UBYTE(1u):;
#line 590 "cpu.bas"
goto L43_L_MABS;
break;
case BAS_UBYTE(2u):;
#line 590 "cpu.bas"
goto L44_L_MZX;
break;
case BAS_UBYTE(3u):;
#line 590 "cpu.bas"
goto L45_L_MABSXR;
break;
case BAS_UBYTE(4u):;
#line 590 "cpu.bas"
goto L46_L_MABSXW;
break;
case BAS_UBYTE(5u):;
#line 590 "cpu.bas"
goto L47_L_MZY;
break;
case BAS_UBYTE(6u):;
#line 590 "cpu.bas"
goto L48_L_MABSYR;
break;
case BAS_UBYTE(7u):;
#line 590 "cpu.bas"
goto L49_L_MSHY;
break;
case BAS_UBYTE(8u):;
#line 590 "cpu.bas"
goto L50_L_MSHX;
break;
case BAS_UBYTE(9u):;
#line 590 "cpu.bas"
goto L51_L_MSHS;
break;
case BAS_UBYTE(10u):;
#line 590 "cpu.bas"
goto L52_L_MIMPL;
break;
case BAS_UBYTE(11u):;
#line 590 "cpu.bas"
goto L53_L_MIMM;
break;
case BAS_UBYTE(12u):;
#line 590 "cpu.bas"
goto L54_L_MBRANCH;
break;
case BAS_UBYTE(13u):;
#line 590 "cpu.bas"
goto L55_L_MINDX;
break;
case BAS_UBYTE(14u):;
#line 590 "cpu.bas"
goto L56_L_MABSYW;
break;
case BAS_UBYTE(15u):;
#line 590 "cpu.bas"
goto L57_L_MSAX;
break;
case BAS_UBYTE(16u):;
#line 590 "cpu.bas"
goto L58_L_MINDYW;
break;
case BAS_UBYTE(17u):;
#line 590 "cpu.bas"
goto L59_L_MINDYR;
break;
}
#line 592 "cpu.bas"
S_Y = RB_f();
#line 592 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 592 "cpu.bas"
ADDR_i = S_Y;
#line 592 "cpu.bas"
S_Y = BAS_UBYTE(255u);
#line 592 "cpu.bas"
goto L60_L_DONEMODE;
#line 593 "cpu.bas"
L44_L_MZX: ;
#line 593 "cpu.bas"
S_Y = RB_f();
#line 593 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 593 "cpu.bas"
ADDR_i = S_Y;
#line 593 "cpu.bas"
DUMMYRB_f();
#line 593 "cpu.bas"
F_i = INCADDR_f(CPU_u.X_Y);
#line 593 "cpu.bas"
S_Y = BAS_UBYTE(255u);
#line 593 "cpu.bas"
goto L60_L_DONEMODE;
#line 594 "cpu.bas"
L47_L_MZY: ;
#line 594 "cpu.bas"
S_Y = RB_f();
#line 594 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 594 "cpu.bas"
ADDR_i = S_Y;
#line 594 "cpu.bas"
DUMMYRB_f();
#line 594 "cpu.bas"
F_i = INCADDR_f(CPU_u.Y_Y);
#line 594 "cpu.bas"
S_Y = BAS_UBYTE(255u);
#line 594 "cpu.bas"
goto L60_L_DONEMODE;
#line 595 "cpu.bas"
L55_L_MINDX: ;
#line 595 "cpu.bas"
S_Y = RB_f();
#line 595 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 595 "cpu.bas"
ADDR_i = S_Y;
#line 595 "cpu.bas"
DUMMYRB_f();
#line 595 "cpu.bas"
F_i = INCADDR_f(CPU_u.X_Y);
#line 596 "cpu.bas"
S_Y = RB_f();
#line 596 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 596 "cpu.bas"
goto L61_L_ABSNOINDEX;
#line 597 "cpu.bas"
L58_L_MINDYW: ;
#line 597 "cpu.bas"
S_Y = RB_f();
#line 597 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 597 "cpu.bas"
ADDR_i = S_Y;
#line 597 "cpu.bas"
S_Y = RB_f();
#line 597 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 597 "cpu.bas"
F_i = CPU_u.Y_Y;
#line 597 "cpu.bas"
goto L62_L_ABSWRITE;
#line 598 "cpu.bas"
L59_L_MINDYR: ;
#line 598 "cpu.bas"
S_Y = RB_f();
#line 598 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 598 "cpu.bas"
ADDR_i = S_Y;
#line 598 "cpu.bas"
S_Y = RB_f();
#line 598 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 598 "cpu.bas"
F_i = CPU_u.Y_Y;
#line 598 "cpu.bas"
goto L63_L_ABSREAD;
#line 599 "cpu.bas"
L57_L_MSAX: ;
#line 599 "cpu.bas"
S_Y = RB_f();
#line 599 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 599 "cpu.bas"
ADDR_i = S_Y;
#line 599 "cpu.bas"
S_Y = RB_f();
#line 599 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 599 "cpu.bas"
F_i = CPU_u.Y_Y;
#line 599 "cpu.bas"
D_Y = (CPU_u.X_Y & CPU_u.A_Y);
#line 599 "cpu.bas"
goto L64_L_ABSBUGGY;
#line 601 "cpu.bas"
L43_L_MABS: ;
#line 601 "cpu.bas"
S_Y = RB_f();
#line 601 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 601 "cpu.bas"
goto L65_L_ABSPCNOINDEX;
#line 602 "cpu.bas"
L65_L_ABSPCNOINDEX: ;
#line 602 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 602 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 603 "cpu.bas"
L61_L_ABSNOINDEX: ;
#line 603 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 604 "cpu.bas"
S_Y = BAS_UBYTE(255u);
#line 604 "cpu.bas"
goto L60_L_DONEMODE;
#line 606 "cpu.bas"
L46_L_MABSXW: ;
#line 606 "cpu.bas"
S_Y = RB_f();
#line 606 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 606 "cpu.bas"
F_i = CPU_u.X_Y;
#line 606 "cpu.bas"
goto L66_L_ABSPCWRITE;
#line 607 "cpu.bas"
L56_L_MABSYW: ;
#line 607 "cpu.bas"
S_Y = RB_f();
#line 607 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 607 "cpu.bas"
F_i = CPU_u.Y_Y;
#line 608 "cpu.bas"
L66_L_ABSPCWRITE: ;
#line 608 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 608 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 609 "cpu.bas"
L62_L_ABSWRITE: ;
#line 609 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 609 "cpu.bas"
F_i = INCADDR_f(F_i);
#line 609 "cpu.bas"
DUMMYRB_f();
#line 609 "cpu.bas"
ADDR_i += F_i;
#line 610 "cpu.bas"
S_Y = BAS_UBYTE(255u);
#line 610 "cpu.bas"
goto L60_L_DONEMODE;
#line 612 "cpu.bas"
L45_L_MABSXR: ;
#line 612 "cpu.bas"
S_Y = RB_f();
#line 612 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 612 "cpu.bas"
F_i = CPU_u.X_Y;
#line 612 "cpu.bas"
goto L67_L_ABSPCREAD;
#line 613 "cpu.bas"
L48_L_MABSYR: ;
#line 613 "cpu.bas"
S_Y = RB_f();
#line 613 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 613 "cpu.bas"
F_i = CPU_u.Y_Y;
#line 614 "cpu.bas"
L67_L_ABSPCREAD: ;
#line 614 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 614 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 615 "cpu.bas"
L63_L_ABSREAD: ;
#line 615 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 615 "cpu.bas"
F_i = INCADDR_f(F_i);
#line 615 "cpu.bas"
if(F_i) {
#line 615 "cpu.bas"
DUMMYRB_f();
#line 615 "cpu.bas"
ADDR_i += F_i;
}
#line 616 "cpu.bas"
goto L60_L_DONEMODE;
#line 618 "cpu.bas"
L51_L_MSHS: ;
#line 618 "cpu.bas"
S_Y = RB_f();
#line 618 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 618 "cpu.bas"
F_i = CPU_u.Y_Y;
#line 618 "cpu.bas"
D_Y = (CPU_u.X_Y & CPU_u.A_Y);
#line 618 "cpu.bas"
goto L68_L_ABSPCBUGGY;
#line 619 "cpu.bas"
L49_L_MSHY: ;
#line 619 "cpu.bas"
S_Y = RB_f();
#line 619 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 619 "cpu.bas"
F_i = CPU_u.X_Y;
#line 619 "cpu.bas"
D_Y = CPU_u.Y_Y;
#line 619 "cpu.bas"
goto L68_L_ABSPCBUGGY;
#line 620 "cpu.bas"
L50_L_MSHX: ;
#line 620 "cpu.bas"
S_Y = RB_f();
#line 620 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 620 "cpu.bas"
F_i = CPU_u.Y_Y;
#line 620 "cpu.bas"
D_Y = CPU_u.X_Y;
#line 621 "cpu.bas"
L68_L_ABSPCBUGGY: ;
#line 621 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 621 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 622 "cpu.bas"
L64_L_ABSBUGGY: ;
#line 622 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 622 "cpu.bas"
F_i = INCADDR_f(F_i);
#line 622 "cpu.bas"
DUMMYRB_f();
#line 622 "cpu.bas"
S_Y = (((ADDR_i + F_i) / BAS_INT(256)) & D_Y);
#line 622 "cpu.bas"
if(F_i) {
#line 622 "cpu.bas"
ADDR_i = ((ADDR_i & BAS_UBYTE(255u)) + (BAS_INT(256) * S_Y));
}
#line 623 "cpu.bas"
goto L60_L_DONEMODE;
#line 631 "cpu.bas"
L54_L_MBRANCH: ;
#line 631 "cpu.bas"
S_Y = RB_f();
#line 632 "cpu.bas"
L53_L_MIMM: ;
#line 632 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 632 "cpu.bas"
goto L60_L_DONEMODE;
#line 633 "cpu.bas"
L52_L_MIMPL: ;
#line 633 "cpu.bas"
S_Y = RB_f();
#line 636 "cpu.bas"
L60_L_DONEMODE: ;
#line 636 "cpu.bas"
if(BAS_INT(0)) {
#line 636 "cpu.bas"
UsingFormatter ("mode=## addr=\\  \\ t=\\\\ PC=\\  \\").DoParam(GET_STREAM_OUTPUT(BAS_UBYTE(2u)), MODE_Y, HEXS_f((
#line 636 "cpu.bas"
(BAS_LNG)std::round(ADDR_i) & 65535), BAS_UBYTE(4u)), HEXS_f(S_Y, BAS_UBYTE(2u)), HEXS_f((
#line 636 "cpu.bas"
(BAS_LNG)std::round(CPU_u.PC_i) & 65535), BAS_UBYTE(4u))) << PrintCRLFtag{}; 
}
#line 651 "cpu.bas"
if((OP_i < BAS_UBYTE(36u))) {
#line 652 "cpu.bas"
switch(((OP_i - BAS_BYTE(0)) + BAS_UBYTE(1u))) {
case BAS_UBYTE(1u):;
#line 652 "cpu.bas"
goto L69_L_DOORA;
break;
case BAS_UBYTE(2u):;
#line 652 "cpu.bas"
goto L70_L_DOAND;
break;
case BAS_UBYTE(3u):;
#line 652 "cpu.bas"
goto L71_L_DOEOR;
break;
case BAS_UBYTE(4u):;
#line 652 "cpu.bas"
goto L72_L_DOADC;
break;
case BAS_UBYTE(5u):;
#line 652 "cpu.bas"
goto L73_L_DOSTA;
break;
case BAS_UBYTE(6u):;
#line 652 "cpu.bas"
goto L74_L_DOLDA;
break;
case BAS_UBYTE(7u):;
#line 652 "cpu.bas"
goto L75_L_DOCMP;
break;
case BAS_UBYTE(8u):;
#line 652 "cpu.bas"
goto L76_L_DOSBC;
break;
case BAS_UBYTE(9u):;
#line 652 "cpu.bas"
goto L77_L_DOASLA;
break;
case BAS_UBYTE(10u):;
#line 653 "cpu.bas"
goto L78_L_DONOP;
break;
case BAS_UBYTE(11u):;
#line 653 "cpu.bas"
goto L79_L_DOBRK;
break;
case BAS_UBYTE(12u):;
#line 653 "cpu.bas"
goto L80_L_DOJSR;
break;
case BAS_UBYTE(13u):;
#line 653 "cpu.bas"
goto L81_L_DORTI;
break;
case BAS_UBYTE(14u):;
#line 653 "cpu.bas"
goto L82_L_DORTS;
break;
case BAS_UBYTE(15u):;
#line 653 "cpu.bas"
goto L83_L_DOANE;
break;
case BAS_UBYTE(16u):;
#line 653 "cpu.bas"
goto L84_L_DOTAX;
break;
case BAS_UBYTE(17u):;
#line 653 "cpu.bas"
goto L85_L_DOSBX;
break;
case BAS_UBYTE(18u):;
#line 653 "cpu.bas"
goto L86_L_DOROLA;
break;
case BAS_UBYTE(19u):;
#line 654 "cpu.bas"
goto L87_L_DOANC;
break;
case BAS_UBYTE(20u):;
#line 654 "cpu.bas"
goto L88_L_DOBCS;
break;
case BAS_UBYTE(21u):;
#line 654 "cpu.bas"
goto L89_L_DOPHP;
break;
case BAS_UBYTE(22u):;
#line 654 "cpu.bas"
goto L90_L_DOPLP;
break;
case BAS_UBYTE(23u):;
#line 654 "cpu.bas"
goto L91_L_DOPHA;
break;
case BAS_UBYTE(24u):;
#line 654 "cpu.bas"
goto L92_L_DOPLA;
break;
case BAS_UBYTE(25u):;
#line 654 "cpu.bas"
goto L93_L_DODEY;
break;
case BAS_UBYTE(26u):;
#line 654 "cpu.bas"
goto L94_L_DOTAY;
break;
case BAS_UBYTE(27u):;
#line 654 "cpu.bas"
goto L95_L_DOLSRA;
break;
case BAS_UBYTE(28u):;
#line 655 "cpu.bas"
goto L96_L_DOINX;
break;
case BAS_UBYTE(29u):;
#line 655 "cpu.bas"
goto L97_L_DOCLD;
break;
case BAS_UBYTE(30u):;
#line 655 "cpu.bas"
goto L98_L_DODEX;
break;
case BAS_UBYTE(31u):;
#line 655 "cpu.bas"
goto L99_L_DOBPL;
break;
case BAS_UBYTE(32u):;
#line 655 "cpu.bas"
goto L100_L_DOBMI;
break;
case BAS_UBYTE(33u):;
#line 655 "cpu.bas"
goto L101_L_DOBVC;
break;
case BAS_UBYTE(34u):;
#line 655 "cpu.bas"
goto L102_L_DOBVS;
break;
case BAS_UBYTE(35u):;
#line 655 "cpu.bas"
goto L103_L_DOBCC;
break;
case BAS_UBYTE(36u):;
#line 655 "cpu.bas"
goto L104_L_DORORA;
break;
}
} else {
#line 657 "cpu.bas"
switch(((OP_i - BAS_UBYTE(36u)) + BAS_UBYTE(1u))) {
case BAS_UBYTE(1u):;
#line 657 "cpu.bas"
goto L105_L_DOINY;
break;
case BAS_UBYTE(2u):;
#line 657 "cpu.bas"
goto L106_L_DOBEQ;
break;
case BAS_UBYTE(3u):;
#line 657 "cpu.bas"
goto L107_L_DOSED;
break;
case BAS_UBYTE(4u):;
#line 657 "cpu.bas"
goto L108_L_DOTSX;
break;
case BAS_UBYTE(5u):;
#line 657 "cpu.bas"
goto L109_L_DOASL;
break;
case BAS_UBYTE(6u):;
#line 657 "cpu.bas"
goto L110_L_DOROL;
break;
case BAS_UBYTE(7u):;
#line 657 "cpu.bas"
goto L111_L_DOLSR;
break;
case BAS_UBYTE(8u):;
#line 657 "cpu.bas"
goto L112_L_DOROR;
break;
case BAS_UBYTE(9u):;
#line 657 "cpu.bas"
goto L113_L_DOSTX;
break;
case BAS_UBYTE(10u):;
#line 658 "cpu.bas"
goto L114_L_DOLDX;
break;
case BAS_UBYTE(11u):;
#line 658 "cpu.bas"
goto L115_L_DODEC;
break;
case BAS_UBYTE(12u):;
#line 658 "cpu.bas"
goto L116_L_DOINC;
break;
case BAS_UBYTE(13u):;
#line 658 "cpu.bas"
goto L117_L_DOTXA;
break;
case BAS_UBYTE(14u):;
#line 658 "cpu.bas"
goto L118_L_DOTXS;
break;
case BAS_UBYTE(15u):;
#line 658 "cpu.bas"
goto L119_L_DOSLO;
break;
case BAS_UBYTE(16u):;
#line 658 "cpu.bas"
goto L120_L_DORLA;
break;
case BAS_UBYTE(17u):;
#line 658 "cpu.bas"
goto L121_L_DOSRE;
break;
case BAS_UBYTE(18u):;
#line 658 "cpu.bas"
goto L122_L_DORRA;
break;
case BAS_UBYTE(19u):;
#line 659 "cpu.bas"
goto L123_L_DOSAX;
break;
case BAS_UBYTE(20u):;
#line 659 "cpu.bas"
goto L124_L_DOLAX;
break;
case BAS_UBYTE(21u):;
#line 659 "cpu.bas"
goto L125_L_DODCP;
break;
case BAS_UBYTE(22u):;
#line 659 "cpu.bas"
goto L126_L_DOISB;
break;
case BAS_UBYTE(23u):;
#line 659 "cpu.bas"
goto L127_L_DOSHS;
break;
case BAS_UBYTE(24u):;
#line 659 "cpu.bas"
goto L128_L_DOLAS;
break;
case BAS_UBYTE(25u):;
#line 659 "cpu.bas"
goto L129_L_DOBNE;
break;
case BAS_UBYTE(26u):;
#line 659 "cpu.bas"
goto L130_L_DOBIT;
break;
case BAS_UBYTE(27u):;
#line 659 "cpu.bas"
goto L131_L_DOJMP;
break;
case BAS_UBYTE(28u):;
#line 660 "cpu.bas"
goto L132_L_DOJMI;
break;
case BAS_UBYTE(29u):;
#line 660 "cpu.bas"
goto L133_L_DOSTY;
break;
case BAS_UBYTE(30u):;
#line 660 "cpu.bas"
goto L134_L_DOLDY;
break;
case BAS_UBYTE(31u):;
#line 660 "cpu.bas"
goto L135_L_DOCPY;
break;
case BAS_UBYTE(32u):;
#line 660 "cpu.bas"
goto L136_L_DOCPX;
break;
case BAS_UBYTE(33u):;
#line 660 "cpu.bas"
goto L137_L_DOASR;
break;
case BAS_UBYTE(34u):;
#line 660 "cpu.bas"
goto L138_L_DOARR;
break;
case BAS_UBYTE(35u):;
#line 660 "cpu.bas"
goto L139_L_DOCLC;
break;
case BAS_UBYTE(36u):;
#line 660 "cpu.bas"
goto L140_L_DOSEC;
break;
case BAS_UBYTE(37u):;
#line 661 "cpu.bas"
goto L141_L_DOCLI;
break;
case BAS_UBYTE(38u):;
#line 661 "cpu.bas"
goto L142_L_DOSEI;
break;
case BAS_UBYTE(39u):;
#line 661 "cpu.bas"
goto L143_L_DOTYA;
break;
case BAS_UBYTE(40u):;
#line 661 "cpu.bas"
goto L144_L_DOCLV;
break;
case BAS_UBYTE(41u):;
#line 661 "cpu.bas"
goto L145_L_DORESET;
break;
case BAS_UBYTE(42u):;
#line 661 "cpu.bas"
goto L146_L_DONMI;
break;
case BAS_UBYTE(43u):;
#line 661 "cpu.bas"
goto L147_L_DOIRQ;
break;
}
}
#line 663 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "RESET HIT: UNKNOWN OPCODE  " << OP_i << ' ' << PrintCRLFtag{}; 
#line 664 "cpu.bas"
B_StmtERROR(BAS_UBYTE(5u));
#line 666 "cpu.bas"
L78_L_DONOP: ;
#line 666 "cpu.bas"
if((MODE_Y != BAS_UBYTE(10u))) {
#line 667 "cpu.bas"
DUMMYRB_f();
}
#line 667 "cpu.bas"
goto L148_L_DONEOP;
#line 668 "cpu.bas"
L139_L_DOCLC: ;
#line 668 "cpu.bas"
CPU_u.C_i = BAS_BYTE(0);
#line 668 "cpu.bas"
goto L148_L_DONEOP;
#line 669 "cpu.bas"
L140_L_DOSEC: ;
#line 669 "cpu.bas"
CPU_u.C_i = BAS_UBYTE(1u);
#line 669 "cpu.bas"
goto L148_L_DONEOP;
#line 670 "cpu.bas"
L97_L_DOCLD: ;
#line 670 "cpu.bas"
CPU_u.D_y = BAS_BYTE(0);
#line 670 "cpu.bas"
goto L148_L_DONEOP;
#line 671 "cpu.bas"
L107_L_DOSED: ;
#line 671 "cpu.bas"
CPU_u.D_y = BAS_BYTE(-1);
#line 671 "cpu.bas"
goto L148_L_DONEOP;
#line 672 "cpu.bas"
L144_L_DOCLV: ;
#line 672 "cpu.bas"
CPU_u.V_Y = BAS_BYTE(0);
#line 672 "cpu.bas"
goto L148_L_DONEOP;
#line 673 "cpu.bas"
L141_L_DOCLI: ;
#line 673 "cpu.bas"
CPU_u.I_Y = BAS_BYTE(0);
#line 673 "cpu.bas"
goto L148_L_DONEOP;
#line 674 "cpu.bas"
L142_L_DOSEI: ;
#line 674 "cpu.bas"
CPU_u.I_Y = BAS_UBYTE(4u);
#line 674 "cpu.bas"
goto L148_L_DONEOP;
#line 675 "cpu.bas"
L100_L_DOBMI: ;
#line 675 "cpu.bas"
if((CPU_u.NZ_i >= BAS_UBYTE(128u))) {
#line 675 "cpu.bas"
goto L149_L_BRANCHOP;
} else {
#line 675 "cpu.bas"
goto L148_L_DONEOP;
}
#line 676 "cpu.bas"
L99_L_DOBPL: ;
#line 676 "cpu.bas"
if((CPU_u.NZ_i < BAS_UBYTE(128u))) {
#line 676 "cpu.bas"
goto L149_L_BRANCHOP;
} else {
#line 676 "cpu.bas"
goto L148_L_DONEOP;
}
#line 677 "cpu.bas"
L102_L_DOBVS: ;
#line 677 "cpu.bas"
if((CPU_u.V_Y & BAS_UBYTE(64u))) {
#line 677 "cpu.bas"
goto L149_L_BRANCHOP;
} else {
#line 677 "cpu.bas"
goto L148_L_DONEOP;
}
#line 678 "cpu.bas"
L101_L_DOBVC: ;
#line 678 "cpu.bas"
if(((CPU_u.V_Y & BAS_UBYTE(64u)) == BAS_BYTE(0))) {
#line 678 "cpu.bas"
goto L149_L_BRANCHOP;
} else {
#line 678 "cpu.bas"
goto L148_L_DONEOP;
}
#line 679 "cpu.bas"
L106_L_DOBEQ: ;
#line 679 "cpu.bas"
if(((CPU_u.NZ_i & BAS_UBYTE(255u)) == BAS_BYTE(0))) {
#line 679 "cpu.bas"
goto L149_L_BRANCHOP;
} else {
#line 679 "cpu.bas"
goto L148_L_DONEOP;
}
#line 680 "cpu.bas"
L129_L_DOBNE: ;
#line 680 "cpu.bas"
if(((CPU_u.NZ_i & BAS_UBYTE(255u)) != BAS_BYTE(0))) {
#line 680 "cpu.bas"
goto L149_L_BRANCHOP;
} else {
#line 680 "cpu.bas"
goto L148_L_DONEOP;
}
#line 681 "cpu.bas"
L88_L_DOBCS: ;
#line 681 "cpu.bas"
if(CPU_u.C_i) {
#line 681 "cpu.bas"
goto L149_L_BRANCHOP;
} else {
#line 681 "cpu.bas"
goto L148_L_DONEOP;
}
#line 682 "cpu.bas"
L103_L_DOBCC: ;
#line 682 "cpu.bas"
if((CPU_u.C_i == BAS_BYTE(0))) {
#line 684 "cpu.bas"
L149_L_BRANCHOP: ;
#line 684 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 684 "cpu.bas"
DUMMYRB_f();
#line 686 "cpu.bas"
BYTETEMP_y = S_Y;
#line 689 "cpu.bas"
F_i = INCADDR_f(BYTETEMP_y);
#line 689 "cpu.bas"
if(F_i) {
#line 689 "cpu.bas"
DUMMYRB_f();
#line 689 "cpu.bas"
ADDR_i += F_i;
}
#line 690 "cpu.bas"
CPU_u.PC_i = ADDR_i;
}
#line 692 "cpu.bas"
goto L148_L_DONEOP;
#line 694 "cpu.bas"
L73_L_DOSTA: ;
#line 694 "cpu.bas"
WB_f(CPU_u.A_Y);
#line 694 "cpu.bas"
goto L148_L_DONEOP;
#line 695 "cpu.bas"
L113_L_DOSTX: ;
#line 695 "cpu.bas"
WB_f((S_Y & CPU_u.X_Y));
#line 695 "cpu.bas"
goto L148_L_DONEOP;
#line 696 "cpu.bas"
L133_L_DOSTY: ;
#line 696 "cpu.bas"
WB_f((S_Y & CPU_u.Y_Y));
#line 696 "cpu.bas"
goto L148_L_DONEOP;
#line 697 "cpu.bas"
L123_L_DOSAX: ;
#line 697 "cpu.bas"
WB_f(((S_Y & CPU_u.A_Y) & CPU_u.X_Y));
#line 697 "cpu.bas"
goto L148_L_DONEOP;
#line 698 "cpu.bas"
L127_L_DOSHS: ;
#line 698 "cpu.bas"
CPU_u.S_Y = WBR_f((CPU_u.A_Y & CPU_u.X_Y));
#line 698 "cpu.bas"
goto L148_L_DONEOP;
#line 700 "cpu.bas"
L74_L_DOLDA: ;
#line 700 "cpu.bas"
S_Y = RB_f();
#line 700 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 701 "cpu.bas"
L114_L_DOLDX: ;
#line 701 "cpu.bas"
S_Y = RB_f();
#line 701 "cpu.bas"
CPU_u.X_Y = S_Y;
#line 701 "cpu.bas"
goto L151_L_NZDONEOP;
#line 702 "cpu.bas"
L134_L_DOLDY: ;
#line 702 "cpu.bas"
S_Y = RB_f();
#line 702 "cpu.bas"
CPU_u.Y_Y = S_Y;
#line 702 "cpu.bas"
goto L151_L_NZDONEOP;
#line 703 "cpu.bas"
L124_L_DOLAX: ;
#line 703 "cpu.bas"
S_Y = RB_f();
#line 703 "cpu.bas"
CPU_u.X_Y = S_Y;
#line 703 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 704 "cpu.bas"
L128_L_DOLAS: ;
#line 704 "cpu.bas"
S_Y = (RB_f() & CPU_u.S_Y);
#line 704 "cpu.bas"
CPU_u.S_Y = S_Y;
#line 704 "cpu.bas"
CPU_u.X_Y = S_Y;
#line 704 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 706 "cpu.bas"
L118_L_DOTXS: ;
#line 706 "cpu.bas"
S_Y = CPU_u.X_Y;
#line 706 "cpu.bas"
CPU_u.S_Y = S_Y;
#line 706 "cpu.bas"
goto L148_L_DONEOP;
#line 707 "cpu.bas"
L117_L_DOTXA: ;
#line 707 "cpu.bas"
S_Y = CPU_u.X_Y;
#line 707 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 708 "cpu.bas"
L143_L_DOTYA: ;
#line 708 "cpu.bas"
S_Y = CPU_u.Y_Y;
#line 708 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 709 "cpu.bas"
L84_L_DOTAX: ;
#line 709 "cpu.bas"
S_Y = CPU_u.A_Y;
#line 709 "cpu.bas"
CPU_u.X_Y = S_Y;
#line 709 "cpu.bas"
goto L151_L_NZDONEOP;
#line 710 "cpu.bas"
L94_L_DOTAY: ;
#line 710 "cpu.bas"
S_Y = CPU_u.A_Y;
#line 710 "cpu.bas"
CPU_u.Y_Y = S_Y;
#line 710 "cpu.bas"
goto L151_L_NZDONEOP;
#line 711 "cpu.bas"
L108_L_DOTSX: ;
#line 711 "cpu.bas"
S_Y = CPU_u.S_Y;
#line 711 "cpu.bas"
CPU_u.X_Y = S_Y;
#line 711 "cpu.bas"
goto L151_L_NZDONEOP;
#line 713 "cpu.bas"
L70_L_DOAND: ;
#line 713 "cpu.bas"
S_Y = (RB_f() & CPU_u.A_Y);
#line 713 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 714 "cpu.bas"
L69_L_DOORA: ;
#line 714 "cpu.bas"
S_Y = (RB_f() | CPU_u.A_Y);
#line 714 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 715 "cpu.bas"
L71_L_DOEOR: ;
#line 715 "cpu.bas"
S_Y = (RB_f() ^ CPU_u.A_Y);
#line 715 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 716 "cpu.bas"
L83_L_DOANE: ;
#line 716 "cpu.bas"
S_Y = (RB_f() ^ CPU_u.X_Y);
#line 716 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 717 "cpu.bas"
L87_L_DOANC: ;
#line 717 "cpu.bas"
S_Y = (RB_f() & CPU_u.A_Y);
#line 717 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(128u));
#line 717 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 718 "cpu.bas"
L98_L_DODEX: ;
#line 718 "cpu.bas"
S_Y = ((CPU_u.X_Y + BAS_BYTE(-1)) & BAS_UBYTE(255u));
#line 718 "cpu.bas"
CPU_u.X_Y = S_Y;
#line 718 "cpu.bas"
goto L151_L_NZDONEOP;
#line 719 "cpu.bas"
L96_L_DOINX: ;
#line 719 "cpu.bas"
S_Y = ((CPU_u.X_Y + BAS_UBYTE(1u)) & BAS_UBYTE(255u));
#line 719 "cpu.bas"
CPU_u.X_Y = S_Y;
#line 719 "cpu.bas"
goto L151_L_NZDONEOP;
#line 720 "cpu.bas"
L93_L_DODEY: ;
#line 720 "cpu.bas"
S_Y = ((CPU_u.Y_Y + BAS_BYTE(-1)) & BAS_UBYTE(255u));
#line 720 "cpu.bas"
CPU_u.Y_Y = S_Y;
#line 720 "cpu.bas"
goto L151_L_NZDONEOP;
#line 721 "cpu.bas"
L105_L_DOINY: ;
#line 721 "cpu.bas"
S_Y = ((CPU_u.Y_Y + BAS_UBYTE(1u)) & BAS_UBYTE(255u));
#line 721 "cpu.bas"
CPU_u.Y_Y = S_Y;
#line 721 "cpu.bas"
goto L151_L_NZDONEOP;
#line 722 "cpu.bas"
L115_L_DODEC: ;
#line 722 "cpu.bas"
S_Y = WBR_f((WBR_f(RB_f()) + BAS_BYTE(-1)));
#line 722 "cpu.bas"
goto L151_L_NZDONEOP;
#line 723 "cpu.bas"
L116_L_DOINC: ;
#line 723 "cpu.bas"
S_Y = WBR_f((WBR_f(RB_f()) + BAS_UBYTE(1u)));
#line 723 "cpu.bas"
goto L151_L_NZDONEOP;
#line 724 "cpu.bas"
L125_L_DODCP: ;
#line 724 "cpu.bas"
I1_Y = (WBR_f((WBR_f(RB_f()) + BAS_BYTE(-1))) ^ BAS_UBYTE(255u));
#line 724 "cpu.bas"
I2_Y = CPU_u.A_Y;
#line 724 "cpu.bas"
goto L152_L_CMPCOMMON;
#line 725 "cpu.bas"
L126_L_DOISB: ;
#line 725 "cpu.bas"
I1_Y = (WBR_f((WBR_f(RB_f()) + BAS_UBYTE(1u))) ^ BAS_UBYTE(255u));
#line 725 "cpu.bas"
goto L153_L_SBCCOMMON;
#line 727 "cpu.bas"
L119_L_DOSLO: ;
#line 727 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 727 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(128u));
#line 727 "cpu.bas"
S_Y = (WBR_f((S_Y * BAS_UBYTE(2u))) | CPU_u.A_Y);
#line 727 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 728 "cpu.bas"
L109_L_DOASL: ;
#line 728 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 728 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(128u));
#line 728 "cpu.bas"
S_Y = WBR_f((S_Y * BAS_UBYTE(2u)));
#line 728 "cpu.bas"
goto L151_L_NZDONEOP;
#line 729 "cpu.bas"
L77_L_DOASLA: ;
#line 729 "cpu.bas"
S_Y = CPU_u.A_Y;
#line 729 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(128u));
#line 729 "cpu.bas"
S_Y = ((S_Y * BAS_UBYTE(2u)) & BAS_UBYTE(255u));
#line 729 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 730 "cpu.bas"
L120_L_DORLA: ;
#line 730 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 730 "cpu.bas"
LBC_y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 730 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(128u));
#line 730 "cpu.bas"
S_Y = (WBR_f(((S_Y * BAS_UBYTE(2u)) + LBC_y)) & CPU_u.A_Y);
#line 730 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 731 "cpu.bas"
L110_L_DOROL: ;
#line 731 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 731 "cpu.bas"
LBC_y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 731 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(128u));
#line 731 "cpu.bas"
S_Y = WBR_f(((S_Y * BAS_UBYTE(2u)) + LBC_y));
#line 731 "cpu.bas"
goto L151_L_NZDONEOP;
#line 732 "cpu.bas"
L86_L_DOROLA: ;
#line 732 "cpu.bas"
S_Y = CPU_u.A_Y;
#line 732 "cpu.bas"
LBC_y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 732 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(128u));
#line 732 "cpu.bas"
S_Y = (((S_Y * BAS_UBYTE(2u)) + LBC_y) & BAS_UBYTE(255u));
#line 732 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 733 "cpu.bas"
L121_L_DOSRE: ;
#line 733 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 733 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(1u));
#line 733 "cpu.bas"
S_Y = (WBR_f((S_Y / BAS_UBYTE(2u))) ^ CPU_u.A_Y);
#line 733 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 734 "cpu.bas"
L111_L_DOLSR: ;
#line 734 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 734 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(1u));
#line 734 "cpu.bas"
S_Y = WBR_f((S_Y / BAS_UBYTE(2u)));
#line 734 "cpu.bas"
goto L151_L_NZDONEOP;
#line 735 "cpu.bas"
L95_L_DOLSRA: ;
#line 735 "cpu.bas"
S_Y = CPU_u.A_Y;
#line 735 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(1u));
#line 735 "cpu.bas"
S_Y = (S_Y / BAS_UBYTE(2u));
#line 735 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 736 "cpu.bas"
L137_L_DOASR: ;
#line 736 "cpu.bas"
S_Y = (CPU_u.A_Y & RB_f());
#line 736 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(1u));
#line 736 "cpu.bas"
S_Y = (S_Y / BAS_UBYTE(2u));
#line 736 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 737 "cpu.bas"
L122_L_DORRA: ;
#line 737 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 737 "cpu.bas"
LBC_y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 737 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(1u));
#line 737 "cpu.bas"
I1_Y = WBR_f(((S_Y / BAS_UBYTE(2u)) + (BAS_UBYTE(128u) * LBC_y)));
#line 737 "cpu.bas"
goto L154_L_ADCCOMMON;
#line 738 "cpu.bas"
L112_L_DOROR: ;
#line 738 "cpu.bas"
S_Y = WBR_f(RB_f());
#line 738 "cpu.bas"
LBC_y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 738 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(1u));
#line 738 "cpu.bas"
S_Y = WBR_f(((S_Y / BAS_UBYTE(2u)) + (BAS_UBYTE(128u) * LBC_y)));
#line 738 "cpu.bas"
goto L151_L_NZDONEOP;
#line 739 "cpu.bas"
L104_L_DORORA: ;
#line 739 "cpu.bas"
S_Y = CPU_u.A_Y;
#line 739 "cpu.bas"
LBC_y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 739 "cpu.bas"
CPU_u.C_i = (S_Y & BAS_UBYTE(1u));
#line 739 "cpu.bas"
S_Y = ((S_Y / BAS_UBYTE(2u)) + (BAS_UBYTE(128u) * LBC_y));
#line 739 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 741 "cpu.bas"
L72_L_DOADC: ;
#line 741 "cpu.bas"
I1_Y = RB_f();
#line 742 "cpu.bas"
L154_L_ADCCOMMON: ;
#line 742 "cpu.bas"
I2_Y = CPU_u.A_Y;
#line 742 "cpu.bas"
S_Y = BAS_BYTE(0);
#line 742 "cpu.bas"
D_Y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 742 "cpu.bas"
goto L155_L_ALUOP;
#line 743 "cpu.bas"
L76_L_DOSBC: ;
#line 743 "cpu.bas"
I1_Y = (RB_f() ^ BAS_UBYTE(255u));
#line 744 "cpu.bas"
L153_L_SBCCOMMON: ;
#line 744 "cpu.bas"
I2_Y = CPU_u.A_Y;
#line 744 "cpu.bas"
S_Y = BAS_UBYTE(2u);
#line 744 "cpu.bas"
D_Y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 744 "cpu.bas"
goto L155_L_ALUOP;
#line 745 "cpu.bas"
L138_L_DOARR: ;
#line 745 "cpu.bas"
I1_Y = (RB_f() & CPU_u.A_Y);
#line 745 "cpu.bas"
I2_Y = I1_Y;
#line 745 "cpu.bas"
S_Y = BAS_UBYTE(4u);
#line 745 "cpu.bas"
D_Y = (-((CPU_u.C_i != BAS_BYTE(0)) ? -1 : 0));
#line 745 "cpu.bas"
goto L155_L_ALUOP;
#line 746 "cpu.bas"
L85_L_DOSBX: ;
#line 746 "cpu.bas"
I1_Y = (RB_f() ^ BAS_UBYTE(255u));
#line 746 "cpu.bas"
I2_Y = (CPU_u.A_Y & CPU_u.X_Y);
#line 746 "cpu.bas"
S_Y = BAS_UBYTE(9u);
#line 746 "cpu.bas"
D_Y = BAS_UBYTE(1u);
#line 746 "cpu.bas"
goto L155_L_ALUOP;
#line 747 "cpu.bas"
L136_L_DOCPX: ;
#line 747 "cpu.bas"
I1_Y = (RB_f() ^ BAS_UBYTE(255u));
#line 747 "cpu.bas"
I2_Y = CPU_u.X_Y;
#line 747 "cpu.bas"
goto L152_L_CMPCOMMON;
#line 748 "cpu.bas"
L135_L_DOCPY: ;
#line 748 "cpu.bas"
I1_Y = (RB_f() ^ BAS_UBYTE(255u));
#line 748 "cpu.bas"
I2_Y = CPU_u.Y_Y;
#line 748 "cpu.bas"
goto L152_L_CMPCOMMON;
#line 749 "cpu.bas"
L75_L_DOCMP: ;
#line 749 "cpu.bas"
I1_Y = (RB_f() ^ BAS_UBYTE(255u));
#line 749 "cpu.bas"
I2_Y = CPU_u.A_Y;
#line 750 "cpu.bas"
L152_L_CMPCOMMON: ;
#line 750 "cpu.bas"
S_Y = BAS_UBYTE(1u);
#line 750 "cpu.bas"
D_Y = BAS_UBYTE(1u);
#line 752 "cpu.bas"
L155_L_ALUOP: ;
#line 752 "cpu.bas"
if(BAS_INT(0)) {
#line 752 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "aluop  " << S_Y << " i1= " << I1_Y << " i2= " << I2_Y << " d= " << D_Y << ' ' << PrintCRLFtag{}; 
}
#line 760 "cpu.bas"
T_i = ((I1_Y & BAS_UBYTE(240u)) + (I2_Y & BAS_UBYTE(240u)));
#line 761 "cpu.bas"
L_Y = (((I1_Y & BAS_UBYTE(15u)) + (I2_Y & BAS_UBYTE(15u))) + D_Y);
#line 768 "cpu.bas"
if(BAS_INT(0)) {
#line 768 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "aluop t= " << T_i << " l= " << L_Y << ' ' << PrintCRLFtag{}; 
}
#line 770 "cpu.bas"
CPU_u.NZ_i = ((T_i + L_Y) & BAS_UBYTE(255u));
#line 773 "cpu.bas"
if(((BAS_BYTE(0) & CPU_u.D_y) && ((S_Y & BAS_UBYTE(3u)) == BAS_BYTE(0)))) {
#line 773 "cpu.bas"
LDC_y = ((L_Y >= BAS_UBYTE(10u)) ? -1 : 0);
#line 774 "cpu.bas"
L_Y += (LDC_y & BAS_UBYTE(6u));
}
#line 777 "cpu.bas"
LBC_y = ((L_Y >= BAS_UBYTE(16u)) ? -1 : 0);
#line 778 "cpu.bas"
T_i += (LBC_y & BAS_UBYTE(16u));
#line 779 "cpu.bas"
UBC_y = ((T_i >= BAS_INT(256)) ? -1 : 0);
#line 781 "cpu.bas"
if(BAS_BYTE(0)) {
#line 782 "cpu.bas"
UDC_y = ((T_i >= BAS_UBYTE(160u)) ? -1 : 0);
}
#line 785 "cpu.bas"
if(((S_Y & BAS_UBYTE(1u)) == BAS_BYTE(0))) {
#line 785 "cpu.bas"
CPU_u.V_Y = (((I1_Y ^ T_i) & (I2_Y ^ T_i)) / BAS_UBYTE(2u));
}
#line 786 "cpu.bas"
if((S_Y & BAS_UBYTE(4u))) {
#line 786 "cpu.bas"
T_i = ((I1_Y / BAS_UBYTE(2u)) + (BAS_UBYTE(128u) * D_Y));
#line 786 "cpu.bas"
CPU_u.NZ_i = T_i;
#line 786 "cpu.bas"
L_Y = T_i;
#line 786 "cpu.bas"
T_i &= BAS_UBYTE(240u);
}
#line 788 "cpu.bas"
CPU_u.NZ_i |= ((T_i * BAS_UBYTE(2u)) & BAS_INT(256));
#line 788 "cpu.bas"
CPU_u.C_i = UBC_y;
#line 790 "cpu.bas"
if(BAS_INT(0)) {
#line 790 "cpu.bas"
GET_STREAM_OUTPUT(BAS_UBYTE(2u)) << "aluop t= " << T_i << " l= " << L_Y << " lbc= " << LBC_y << " udc= " << UDC_y << " ubc= " << UBC_y << " NZ= " << CPU_u.NZ_i << " C= " << CPU_u.C_i << ' ' << PrintCRLFtag{}; 
}
#line 792 "cpu.bas"
if((BAS_BYTE(0) & CPU_u.D_y)) {
#line 793 "cpu.bas"
if((((S_Y & BAS_UBYTE(3u)) == BAS_BYTE(0)) && UDC_y)) {
#line 793 "cpu.bas"
T_i += BAS_UBYTE(96u);
#line 793 "cpu.bas"
CPU_u.C_i = BAS_UBYTE(1u);
}
#line 794 "cpu.bas"
if(((S_Y & BAS_UBYTE(4u)) & LDC_y)) {
#line 794 "cpu.bas"
L_Y += BAS_UBYTE(6u);
}
#line 795 "cpu.bas"
if((S_Y & BAS_UBYTE(2u))) {
#line 795 "cpu.bas"
L_Y += ((~LBC_y) & BAS_UBYTE(10u));
#line 795 "cpu.bas"
T_i += ((~UBC_y) & BAS_UBYTE(160u));
}
}
#line 798 "cpu.bas"
if(((S_Y & BAS_UBYTE(1u)) == BAS_BYTE(0))) {
#line 798 "cpu.bas"
CPU_u.A_Y = ((T_i & BAS_UBYTE(240u)) | (L_Y & BAS_UBYTE(15u)));
}
#line 799 "cpu.bas"
if((S_Y & BAS_UBYTE(8u))) {
#line 799 "cpu.bas"
CPU_u.X_Y = ((T_i & BAS_UBYTE(240u)) | (L_Y & BAS_UBYTE(15u)));
}
#line 800 "cpu.bas"
goto L148_L_DONEOP;
#line 803 "cpu.bas"
L130_L_DOBIT: ;
#line 803 "cpu.bas"
S_Y = RB_f();
#line 803 "cpu.bas"
CPU_u.V_Y = S_Y;
#line 803 "cpu.bas"
CPU_u.NZ_i = (((S_Y * BAS_UBYTE(2u)) & BAS_INT(256)) | (S_Y & CPU_u.A_Y));
#line 803 "cpu.bas"
goto L148_L_DONEOP;
#line 806 "cpu.bas"
L92_L_DOPLA: ;
#line 806 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 806 "cpu.bas"
DUMMYRB_f();
#line 806 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 806 "cpu.bas"
S_Y = RB_f();
#line 806 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 806 "cpu.bas"
goto L150_L_ANZDONEOP;
#line 807 "cpu.bas"
L90_L_DOPLP: ;
#line 807 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 807 "cpu.bas"
DUMMYRB_f();
#line 807 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 807 "cpu.bas"
S_Y = RB_f();
#line 807 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 807 "cpu.bas"
SETFLAGS_f(S_Y);
#line 807 "cpu.bas"
goto L148_L_DONEOP;
#line 808 "cpu.bas"
L82_L_DORTS: ;
#line 808 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 808 "cpu.bas"
DUMMYRB_f();
#line 808 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 808 "cpu.bas"
S_Y = RB_f();
#line 809 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 809 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 810 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 810 "cpu.bas"
CPU_u.PC_i = ADDR_i;
#line 810 "cpu.bas"
DUMMYRB_f();
#line 810 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
#line 810 "cpu.bas"
goto L148_L_DONEOP;
#line 811 "cpu.bas"
L81_L_DORTI: ;
#line 811 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 811 "cpu.bas"
DUMMYRB_f();
#line 811 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 811 "cpu.bas"
S_Y = RB_f();
#line 811 "cpu.bas"
SETFLAGS_f(S_Y);
#line 812 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 813 "cpu.bas"
S_Y = RB_f();
#line 813 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 813 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 814 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 814 "cpu.bas"
CPU_u.PC_i = ADDR_i;
#line 814 "cpu.bas"
goto L156_L_LOADNEXTOP;
#line 815 "cpu.bas"
L91_L_DOPHA: ;
#line 815 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 815 "cpu.bas"
WB_f(CPU_u.A_Y);
#line 815 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 815 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 815 "cpu.bas"
goto L148_L_DONEOP;
#line 816 "cpu.bas"
L89_L_DOPHP: ;
#line 816 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 816 "cpu.bas"
WB_f((FLAGS_f() | BAS_UBYTE(48u)));
#line 816 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 816 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 816 "cpu.bas"
goto L148_L_DONEOP;
#line 817 "cpu.bas"
L80_L_DOJSR: ;
#line 818 "cpu.bas"
DUMMYRB_f();
#line 818 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 818 "cpu.bas"
WB_f(
#line 818 "cpu.bas"
std::floor((CPU_u.PC_i / (BAS_DBL)BAS_INT(256))));
#line 818 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 819 "cpu.bas"
WB_f((CPU_u.PC_i & BAS_UBYTE(255u)));
#line 819 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 819 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 820 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 820 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 820 "cpu.bas"
CPU_u.PC_i = ADDR_i;
#line 820 "cpu.bas"
goto L156_L_LOADNEXTOP;
#line 821 "cpu.bas"
L131_L_DOJMP: ;
#line 821 "cpu.bas"
CPU_u.PC_i = ADDR_i;
#line 821 "cpu.bas"
goto L148_L_DONEOP;
#line 822 "cpu.bas"
L132_L_DOJMI: ;
#line 822 "cpu.bas"
S_Y = RB_f();
#line 822 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 822 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 822 "cpu.bas"
CPU_u.PC_i = ADDR_i;
#line 822 "cpu.bas"
goto L156_L_LOADNEXTOP;
#line 824 "cpu.bas"
L79_L_DOBRK: ;
#line 824 "cpu.bas"
D_Y = BAS_UBYTE(254u);
#line 824 "cpu.bas"
S_Y = BAS_UBYTE(48u);
#line 824 "cpu.bas"
goto L157_L_INTRCOMMON;
#line 825 "cpu.bas"
L147_L_DOIRQ: ;
#line 825 "cpu.bas"
D_Y = BAS_UBYTE(254u);
#line 825 "cpu.bas"
S_Y = BAS_UBYTE(32u);
#line 825 "cpu.bas"
CPU_u.PC_i += BAS_BYTE(-1);
#line 825 "cpu.bas"
goto L157_L_INTRCOMMON;
#line 826 "cpu.bas"
L146_L_DONMI: ;
#line 826 "cpu.bas"
D_Y = BAS_UBYTE(250u);
#line 826 "cpu.bas"
S_Y = BAS_UBYTE(32u);
#line 826 "cpu.bas"
CPU_u.PC_i += BAS_BYTE(-1);
#line 827 "cpu.bas"
L157_L_INTRCOMMON: ;
#line 827 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 830 "cpu.bas"
WB_f(
#line 830 "cpu.bas"
std::floor((CPU_u.PC_i / (BAS_DBL)BAS_INT(256))));
#line 830 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 831 "cpu.bas"
WB_f((CPU_u.PC_i & BAS_UBYTE(255u)));
#line 831 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 832 "cpu.bas"
WB_f((FLAGS_f() | S_Y));
#line 832 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 833 "cpu.bas"
L158_L_VECJUMPCOMMON: ;
#line 833 "cpu.bas"
CPU_u.S_Y = (ADDR_i & BAS_UBYTE(255u));
#line 834 "cpu.bas"
ADDR_i = (BAS_UINT(65280u) + D_Y);
#line 834 "cpu.bas"
S_Y = RB_f();
#line 834 "cpu.bas"
F_i = INCADDR_f(BAS_UBYTE(1u));
#line 835 "cpu.bas"
CPU_u.I_Y = BAS_UBYTE(4u);
#line 835 "cpu.bas"
RBMAKEADDR_f(S_Y);
#line 835 "cpu.bas"
CPU_u.PC_i = ADDR_i;
#line 835 "cpu.bas"
goto L156_L_LOADNEXTOP;
#line 836 "cpu.bas"
L145_L_DORESET: ;
#line 836 "cpu.bas"
D_Y = BAS_UBYTE(252u);
#line 836 "cpu.bas"
ADDR_i = (BAS_INT(256) + CPU_u.S_Y);
#line 837 "cpu.bas"
DUMMYRB_f();
#line 837 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 838 "cpu.bas"
DUMMYRB_f();
#line 838 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 839 "cpu.bas"
DUMMYRB_f();
#line 839 "cpu.bas"
F_i = INCADDR_f(BAS_BYTE(-1));
#line 839 "cpu.bas"
goto L158_L_VECJUMPCOMMON;
#line 842 "cpu.bas"
L150_L_ANZDONEOP: ;
#line 843 "cpu.bas"
CPU_u.A_Y = S_Y;
#line 844 "cpu.bas"
L151_L_NZDONEOP: ;
#line 845 "cpu.bas"
CPU_u.NZ_i = S_Y;
#line 846 "cpu.bas"
L148_L_DONEOP: ;
#line 846 "cpu.bas"
ADDR_i = CPU_u.PC_i;
#line 848 "cpu.bas"
L156_L_LOADNEXTOP: ;
#line 849 "cpu.bas"
CPU_u.NEXTOPCODE_i = RB_f();
#line 852 "cpu.bas"
while((CPU_u.DMCDELAY_Y > BAS_BYTE(0))) {
#line 853 "cpu.bas"
DUMMYRB_f();
#line 854 "cpu.bas"
CPU_u.DMCDELAY_Y -= BAS_UBYTE(1u);
}
#line 857 "cpu.bas"
if(((CPU_u.NMI_i & BAS_UBYTE(6u)) == BAS_UBYTE(2u))) {
#line 858 "cpu.bas"
CPU_u.NMI_i |= BAS_UBYTE(4u);
#line 859 "cpu.bas"
if(BAS_INT(0)) {
#line 859 "cpu.bas"
DISASSEMBLYTRACE_f(CPU_u.PC_i, BAS_UBYTE(77u));
}
#line 860 "cpu.bas"
CPUEXECUTE_f(BAS_BYTE(0), BAS_UBYTE(77u));
} else {
#line 857 "cpu.bas"
if(((CPU_u.IRQ_i != BAS_BYTE(0)) && (CPU_u.I_Y == BAS_BYTE(0)))) {
#line 862 "cpu.bas"
if(BAS_INT(0)) {
#line 862 "cpu.bas"
DISASSEMBLYTRACE_f(CPU_u.PC_i, BAS_UBYTE(78u));
}
#line 863 "cpu.bas"
CPUEXECUTE_f(BAS_BYTE(0), BAS_UBYTE(78u));
} else {
#line 865 "cpu.bas"
if(BAS_INT(0)) {
#line 865 "cpu.bas"
DISASSEMBLYTRACE_f(CPU_u.PC_i, CPU_u.NEXTOPCODE_i);
}
#line 866 "cpu.bas"
CPU_u.PC_i += BAS_UBYTE(1u);
}
}
#line 869 "cpu.bas"
if((CPU_u.NMI_i & BAS_UBYTE(1u))) {
#line 869 "cpu.bas"
CPU_u.NMI_i |= BAS_UBYTE(2u);
} else {
#line 869 "cpu.bas"
if((CPU_u.NMI_i & BAS_UBYTE(4u))) {
#line 871 "cpu.bas"
CPU_u.NMI_i = BAS_BYTE(0);
}
}
    return;
B_ERR_FRAME_SUB_END();
}


/* BODY OF SUB PPUTESTVADDRIS3FXX */
#line 2040 "cpu.bas"
BAS_INT PPUTESTVADDRIS3FXX_f()
{
BAS_INT FunctionReturn_i { };
B_ERR_FRAME_SUB_BEGIN();
#line 2041 "cpu.bas"
FunctionReturn_i = ((((PPU_u.BASENTA_i | PPU_u.YCOARSE32_i) >= BAS_INT(3840)) ? -1 : 0) & (((PPU_u.FINEY_Y & BAS_UBYTE(3u)) == BAS_UBYTE(3u)) ? -1 : 0));
    return FunctionReturn_i;
B_ERR_FRAME_SUB_END();
}