text:
847
            P_ANDRS(nullptr, CSTAT[JNTK], CSTAT[JNTK], XNRS[_F.INTR]);

            // line 1850
            P_ADDLOC(nullptr, _F.RKTO, MBORD[_F.RKFR]);

            // line 1851
            P_ADDATK(nullptr, _F.RKTO);

            // line 1852
            P_DELATK(nullptr, _F.RKFR);

            // line 1853
            P_MOVEIT(nullptr, _F.A);

            { /* NOP */ }
        }
        else
        {
            // line 1857
            P_PROACS(nullptr, _F.A);

            // line 1858
            P_MOVEIT(nullptr, _F.A);

            { /* NOP */ }
        }

        { /* NOP */ }
        break;

    case 3:
        { /* NOP */ }
        break;

    case 4:
        // line 1864
        if(_F.A.RMEP)
        {
            // line 1866
            _F.INTS = XTRFS[XTSR[_F.A.RMFR]][XTSF[_F.A.RMTO]];

            // line 1868
            P_MBCAPT(nullptr, MBORD[_F.INTS]);

            // line 1869
            P_DELATK(nullptr, _F.INTS);

            // line 1870
            P_PRPATK(nullptr, _F.INTS);

            // line 1871
            P_MOVEIT(nullptr, _F.A);

            { /* NOP */ }
        }
        else
        {
            // line 1874
            P_LOSEIT(nullptr, _F.A);
        }
        break;

    case 5:
        // line 1877
        P_PROMOT(nullptr, _F.A);

        // line 1878
        P_LOSEIT(nullptr, _F.A);

        { /* NOP */ }
        break;

    case 6:
        // line 1883
        P_PROACS(nullptr, _F.A);

        // line 1884
        P_LOSEIT(nullptr, _F.A);

        { /* NOP */ }
        break;

    case 7:
        // line 1888
        P_PROMOT(nullptr, _F.A);

        // line 1889
        P_PROACS(nullptr, _F.A);

        // line 1890
        P_LOSEIT(nullptr, _F.A);

        { /* NOP */ }
        break;
    }

    // line 1896
    JNTM = OTHER[JNTM];

    // line 1897
    P_CPYRS(nullptr, GENPN[JNTK], TPLOC[XTUMP[C_EP][JNTM]]);

    // line 1898
    P_NOTRS(nullptr, GENTO[JNTK], TMLOC[JNTM]);

    // line 1899
    P_NOTRS(nullptr, _F.INRS, GENPN[JNTK]);

    // line 1900
    P_ANDRS(nullptr, GENFR[JNTK], TMLOC[JNTM], _F.INRS);

    // line 1904
    P_ANDRS(nullptr, _F.INRS, TPLOC[XTUMP[C_EK][JNTM]], ALATK[OTHER[JNTM]]);

    // line 1905
    _F.A.RMCH = (!F_NULRS(nullptr, _F.INRS));

    // line 1906
    P_ANDRS(nullptr, _F.INRS, TPLOC[XTUMP[C_EK][OTHER[JNTM]]], ALATK[JNTM]);

    // line 1907
    _F.A.RMIL = (!F_NULRS(nullptr, _F.INRS));

    // line 1908
    _F._fnvalue = (!_F.A.RMIL);

    // line 1909
    if((!_F.A.RMIL))
    {
        // line 1910
        MVSEL[(JNTK - 1)] = (MVSEL[(JNTK - 1)] + 1);
    }

    // line 1913
    SRCHM[JNTK] = C_H1;

    // line 1914
    NODES = (NODES + 1);

    { /* NOP */ }

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 1919
//================================================================================
// scope: GENONE (level : 2)

// activation record
struct Frame_GENONE
{
    // parameters
    T_TT A;
    T_TS B;

    // locals
    T_RS INRS;
};

// function body
void P_GENONE(void* _slink, T_TT A, T_TS B)
{
    // prologue/frame definition
    Frame_GENONE _F = {A, B };

    assert(nullptr == _slink);

    // subroutine body
    // line 1929
    MOVES[JNTW].RMFR = _F.A;

    // line 1930
    MOVES[JNTW].RMTO = _F.B;

    // line 1931
    MOVES[JNTW].RMCP = MBORD[_F.B];

    // line 1932
    MOVES[JNTW].RMCA = (MBORD[_F.B] != C_MT);

    // line 1933
    P_IORRS(nullptr, _F.INRS, XRSS[_F.A], XRSS[_F.B]);

    // line 1934
    P_ANDRS(nullptr, _F.INRS, _F.INRS, CSTAT[JNTK]);

    // line 1935
    MOVES[JNTW].RMAC = (!F_NULRS(nullptr, _F.INRS));

    // line 1936
    MOVES[JNTW].RMCH = C_false;

    // line 1937
    MOVES[JNTW].RMMT = C_false;

    // line 1938
    MOVES[JNTW].RMIL = C_false;

    // line 1939
    MOVES[JNTW].RMSU = C_false;

    // line 1940
    MOVES[JNTW].RMPR = C_false;

    // line 1941
    MOVES[JNTW].RMOO = C_false;

    // line 1942
    MOVES[JNTW].RMEP = C_false;

    { /* NOP */ }

    // line 1944
    VALUE[JNTW] = 0;

    // line 1945
    if((JNTW < C_ZW))
    {
        // line 1946
        JNTW = (JNTW + 1);
    }

    { /* NOP */ }
}

// line 1950
//================================================================================
// scope: PWNPRO (level : 2)

// activation record
struct Frame_PWNPRO
{
    // locals
    T_TG INTG;
};

// function body
void P_PWNPRO(void* _slink)
{
    // prologue/frame definition
    Frame_PWNPRO _F = { };

    assert(nullptr == _slink);

    // subroutine body
    // line 1956
    MOVES[(JNTW - 1)].RMPR = C_true;

    // line 1957
    MOVES[(JNTW - 1)].RMPP = C_PQ;

    // line 1958
    _FOR_TO(_F.INTG, C_PR, C_PB)
    {
        // line 1960
        MOVES[JNTW] = MOVES[(JNTW - 1)];

        // line 1961
        MOVES[JNTW].RMPP = _F.INTG;

        // line 1962
        JNTW = (JNTW + 1);

        { /* NOP */ }
    }
    _FOR_END(_F.INTG)

    { /* NOP */ }
}

// line 1967
//================================================================================
// scope: GENPWN (level : 2)

// activation record
struct Frame_GENPWN
{
    // parameters
    T_RS A;
    T_RS B;

    // locals
    T_RS IMRS;
    T_RS INRS;
    T_TS INTS;
};

// function body
void P_GENPWN(void* _slink, T_RS A, T_RS B)
{
    // prologue/frame definition
    Frame_GENPWN _F = {A, B };

    assert(nullptr == _slink);

    // subroutine body
    // line 1976
    if((JNTM == C_LITE))
    {
        // line 1978
        P_SFTRS(nullptr, _F.INRS, _F.A, C_S2);

        // line 1979
        P_ANDRS(nullptr, _F.INRS, TPLOC[C_MT], _F.INRS);

        // line 1980
        P_CPYRS(nullptr, _F.IMRS, _F.INRS);

        // line 1981
        P_ANDRS(nullptr, _F.INRS, _F.B, _F.INRS);

        // line 1982
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 1984
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - XTED[C_S2])], _F.INTS);

            // line 1986
            if((_F.INTS >= XTRFS[C_R8][C_F1]))
            {
                // line 1987
                P_PWNPRO(nullptr);
            }

            { /* NOP */ }
        }

        // line 1989
        P_ANDRS(nullptr, _F.INRS, _F.IMRS, XRRS[C_R3]);

        // line 1990
        P_SFTRS(nullptr, _F.INRS, _F.INRS, C_S2);

        // line 1991
        P_ANDRS(nullptr, _F.INRS, _F.INRS, TPLOC[C_MT]);

        // line 1992
        P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.B);

        // line 1993
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 1995
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - (2 * XTED[C_S2]))], _F.INTS);

            // line 1997
            MOVES[(JNTW - 1)].RMEP = C_true;

            { /* NOP */ }
        }

        // line 1999
        P_SFTRS(nullptr, _F.INRS, _F.A, C_B1);

        // line 2000
        P_IORRS(nullptr, _F.IMRS, TMLOC[OTHER[JNTM]], ENPAS[JNTK]);

        // line 2002
        P_ANDRS(nullptr, _F.IMRS, _F.IMRS, _F.B);

        // line 2003
        P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.IMRS);

        // line 2004
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 2006
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - XTED[C_B1])], _F.INTS);

            // line 2008
            MOVES[(JNTW - 1)].RMCA = C_true;

            // line 2009
            MOVES[(JNTW - 1)].RMEP = F_INRSTB(nullptr, ENPAS[JNTK], _F.INTS);

            // line 2011
            if(MOVES[(JNTW - 1)].RMEP)
            {
                // line 2012
                MOVES[(JNTW - 1)].RMCP = C_DP;
            }

            // line 2013
            if((_F.INTS >= XTRFS[C_R8][C_F1]))
            {
                // line 2014
                P_PWNPRO(nullptr);
            }

            { /* NOP */ }
        }

        // line 2016
        P_SFTRS(nullptr, _F.INRS, _F.A, C_B2);

        // line 2017
        P_IORRS(nullptr, _F.IMRS, TMLOC[OTHER[JNTM]], ENPAS[JNTK]);

        // line 2019
        P_ANDRS(nullptr, _F.IMRS, _F.IMRS, _F.B);

        // line 2020
        P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.IMRS);

        // line 2021
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 2023
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - XTED[C_B2])], _F.INTS);

            // line 2025
            MOVES[(JNTW - 1)].RMCA = C_true;

            // line 2026
            MOVES[(JNTW - 1)].RMEP = F_INRSTB(nullptr, ENPAS[JNTK], _F.INTS);

            // line 2028
            if(MOVES[(JNTW - 1)].RMEP)
            {
                // line 2029
                MOVES[(JNTW - 1)].RMCP = C_DP;
            }

            // line 2030
            if((_F.INTS >= XTRFS[C_R8][C_F1]))
            {
                // line 2031
                P_PWNPRO(nullptr);
            }

            { /* NOP */ }
        }

        { /* NOP */ }
    }
    else
    {
        // line 2036
        P_SFTRS(nullptr, _F.INRS, _F.A, C_S4);

        // line 2037
        P_ANDRS(nullptr, _F.INRS, TPLOC[C_MT], _F.INRS);

        // line 2038
        P_CPYRS(nullptr, _F.IMRS, _F.INRS);

        // line 2039
        P_ANDRS(nullptr, _F.INRS, _F.B, _F.INRS);

        // line 2040
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 2042
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - XTED[C_S4])], _F.INTS);

            // line 2044
            if((_F.INTS <= XTRFS[C_R1][C_F8]))
            {
                // line 2045
                P_PWNPRO(nullptr);
            }

            { /* NOP */ }
        }

        // line 2047
        P_ANDRS(nullptr, _F.INRS, _F.IMRS, XRRS[C_R6]);

        // line 2048
        P_SFTRS(nullptr, _F.INRS, _F.INRS, C_S4);

        // line 2049
        P_ANDRS(nullptr, _F.INRS, _F.INRS, TPLOC[C_MT]);

        // line 2050
        P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.B);

        // line 2051
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 2053
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - (2 * XTED[C_S4]))], _F.INTS);

            // line 2055
            MOVES[(JNTW - 1)].RMEP = C_true;

            { /* NOP */ }
        }

        // line 2057
        P_SFTRS(nullptr, _F.INRS, _F.A, C_B3);

        // line 2058
        P_IORRS(nullptr, _F.IMRS, TMLOC[OTHER[JNTM]], ENPAS[JNTK]);

        // line 2060
        P_ANDRS(nullptr, _F.IMRS, _F.IMRS, _F.B);

        // line 2061
        P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.IMRS);

        // line 2062
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 2064
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - XTED[C_B3])], _F.INTS);

            // line 2066
            MOVES[(JNTW - 1)].RMCA = C_true;

            // line 2067
            MOVES[(JNTW - 1)].RMEP = F_INRSTB(nullptr, ENPAS[JNTK], _F.INTS);

            // line 2069
            if(MOVES[(JNTW - 1)].RMEP)
            {
                // line 2070
                MOVES[(JNTW - 1)].RMCP = C_LP;
            }

            // line 2071
            if((_F.INTS <= XTRFS[C_R1][C_F8]))
            {
                // line 2072
                P_PWNPRO(nullptr);
            }

            { /* NOP */ }
        }

        // line 2074
        P_SFTRS(nullptr, _F.INRS, _F.A, C_B4);

        // line 2075
        P_IORRS(nullptr, _F.IMRS, TMLOC[OTHER[JNTM]], ENPAS[JNTK]);

        // line 2077
        P_ANDRS(nullptr, _F.IMRS, _F.IMRS, _F.B);

        // line 2078
        P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.IMRS);

        // line 2079
        while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
        {
            // line 2081
            P_GENONE(nullptr, XTLS[(XTSL[_F.INTS] - XTED[C_B4])], _F.INTS);

            // line 2083
            MOVES[(JNTW - 1)].RMCA = C_true;

            // line 2084
            MOVES[(JNTW - 1)].RMEP = F_INRSTB(nullptr, ENPAS[JNTK], _F.INTS);

            // line 2086
            if(MOVES[(JNTW - 1)].RMEP)
            {
                // line 2087
                MOVES[(JNTW - 1)].RMCP = C_LP;
            }

            // line 2088
            if((_F.INTS <= XTRFS[C_R1][C_F8]))
            {
                // line 2089
                P_PWNPRO(nullptr);
            }

            { /* NOP */ }
        }

        { /* NOP */ }
    }

    { /* NOP */ }
}

// line 2095
//================================================================================
// scope: GENFSL (level : 2)

// activation record
struct Frame_GENFSL
{
    // parameters
    T_RS A;

    // locals
    T_RS IMRS;
    T_TS IMTS;
    T_RS INRS;
    T_TS INTS;
    T_RS IPRS;
};

// function body
void P_GENFSL(void* _slink, T_RS A)
{
    // prologue/frame definition
    Frame_GENFSL _F = {A };

    assert(nullptr == _slink);

    // subroutine body
    // line 2107
    P_ANDRS(nullptr, _F.INRS, _F.A, GENFR[JNTK]);

    // line 2108
    P_NOTRS(nullptr, _F.IMRS, _F.A);

    // line 2109
    P_ANDRS(nullptr, GENFR[JNTK], GENFR[JNTK], _F.IMRS);

    // line 2110
    P_ANDRS(nullptr, _F.IPRS, _F.A, GENPN[JNTK]);

    // line 2111
    P_ANDRS(nullptr, GENPN[JNTK], GENPN[JNTK], _F.IMRS);

    // line 2112
    while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
    {
        // line 2114
        P_ANDRS(nullptr, _F.IMRS, ATKFR[_F.INTS], GENTO[JNTK]);

        // line 2117
        while(F_NXTTS(nullptr, _F.IMRS, _F.IMTS))
        {
            // line 2118
            P_GENONE(nullptr, T_TT::C(_F.INTS), _F.IMTS);
        }

        { /* NOP */ }
    }

    // line 2120
    P_GENPWN(nullptr, _F.IPRS, GENTO[JNTK]);

    { /* NOP */ }
}

// line 2124
//================================================================================
// scope: GENTSL (level : 2)

// activation record
struct Frame_GENTSL
{
    // parameters
    T_RS A;

    // locals
    T_RS IMRS;
    T_TS IMTS;
    T_RS INRS;
    T_TS INTS;
    T_RS IPRS;
};

// function body
void P_GENTSL(void* _slink, T_RS A)
{
    // prologue/frame definition
    Frame_GENTSL _F = {A };

    assert(nullptr == _slink);

    // subroutine body
    // line 2136
    P_ANDRS(nullptr, _F.INRS, _F.A, GENTO[JNTK]);

    // line 2137
    P_NOTRS(nullptr, _F.IMRS, _F.A);

    // line 2138
    P_ANDRS(nullptr, GENTO[JNTK], GENTO[JNTK], _F.IMRS);

    // line 2139
    P_CPYRS(nullptr, _F.IPRS, _F.INRS);

    // line 2140
    while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
    {
        // line 2142
        P_ANDRS(nullptr, _F.IMRS, ATKTO[_F.INTS], GENFR[JNTK]);

        // line 2144
        while(F_NXTTS(nullptr, _F.IMRS, _F.IMTS))
        {
            // line 2145
            P_GENONE(nullptr, T_TT::C(_F.IMTS), _F.INTS);
        }

        { /* NOP */ }
    }

    // line 2147
    P_GENPWN(nullptr, GENPN[JNTK], _F.IPRS);

    { /* NOP */ }
}

// line 2151
//================================================================================
// scope: GENCAP (level : 2)

// activation record
struct Frame_GENCAP
{
    // locals
    T_RS INRS;
};

// function body
void P_GENCAP(void* _slink)
{
    // prologue/frame definition
    Frame_GENCAP _F = { };

    assert(nullptr == _slink);

    // subroutine body
    // line 2157
    P_IORRS(nullptr, _F.INRS, ENPAS[JNTK], TMLOC[OTHER[JNTM]]);

    // line 2158
    P_GENTSL(nullptr, _F.INRS);

    { /* NOP */ }
}

// line 2163
//================================================================================
// scope: GENCAS (level : 2)

// activation record
struct Frame_GENCAS
{
    // locals
    T_RS IMRS;
    T_RS INRS;
    T_TQ INTQ;
};

// function body
void P_GENCAS(void* _slink)
{
    // prologue/frame definition
    Frame_GENCAS _F = { };

    assert(nullptr == _slink);

    // subroutine body
    // line 2171
    _FOR_TO(_F.INTQ, XTMQ[JNTM], _succ(XTMQ[JNTM]))
    {
        // line 2172
        if(F_INRSTB(nullptr, CSTAT[JNTK], XTQS[_F.INTQ]))
        {
            // line 2175
            P_ANDRS(nullptr, _F.INRS, XRQSO[_F.INTQ], ALLOC[JNTK]);

            // line 2177
            P_ANDRS(nullptr, _F.IMRS, XRQSA[_F.INTQ], ALATK[OTHER[JNTM]]);

            // line 2179
            if((F_NULRS(nullptr, _F.INRS) && F_NULRS(nullptr, _F.IMRS)))
            {
                // line 2183
                MOVES[JNTW] = XRQM[_F.INTQ];

                // line 2184
                VALUE[JNTW] = 0;

                // line 2185
                JNTW = (JNTW + 1);

                { /* NOP */ }
            }

            { /* NOP */ }
        }
    }
    _FOR_END(_F.INTQ)

    { /* NOP */ }
}

// line 2191
//================================================================================
// scope: GENALL (level : 2)

// activation record
struct Frame_GENALL
{};

// function body
void P_GENALL(void* _slink)
{
    // prologue/frame definition
    Frame_GENALL _F = { };

    assert(nullptr == _slink);

    // subroutine body
    // line 2194
    P_GENFSL(nullptr, ALLOC[JNTK]);

    // line 2195
    P_GENCAS(nullptr);

    { /* NOP */ }
}

// line 2199
//================================================================================
// scope: LSTMOV (level : 2)

// activation record
struct Frame_LSTMOV
{
    // locals
    T_TW INTW;
};

// function body
void P_LSTMOV(void* _slink)
{
    // prologue/frame definition
    Frame_LSTMOV _F = { };

    assert(nullptr == _slink);

    // subroutine body
    // line 2205
    P_CREATE(nullptr);

    // line 2206
    P_GENALL(nullptr);

    // line 2207
    _FOR_TO(_F.INTW, (C_AW + 1), (JNTW - 1))
    {
        // line 2209
        if(F_UPDATE(nullptr, MOVES[_F.INTW]))
        {
            { /* NOP */ }
        }

        // line 2210
        P_DNDATE(nullptr, MOVES[_F.INTW]);

        { /* NOP */ }
    }
    _FOR_END(_F.INTW)

    { /* NOP */ }
}

// line 2215
//================================================================================
// scope: THEMOV (level : 2)

// activation record
struct Frame_THEMOV
{
    // parameters
    T_RM A;

    // locals
    T_RS INRS;
    T_boolean INTB;
    T_TQ INTQ;
    T_TS INTS;
};

// function body
void P_THEMOV(void* _slink, T_RM A)
{
    // prologue/frame definition
    Frame_THEMOV _F = {A };

    assert(nullptr == _slink);

    // subroutine body
    // line 2225
    LSTMV = _F.A;

    // line 2226
    _F.INTB = F_UPDATE(nullptr, _F.A);

    // line 2230
    BOARD.RBTM = JNTM;

    // line 2231
    P_CPYRS(nullptr, _F.INRS, ENPAS[JNTK]);

    // line 2232
    if(F_NXTTS(nullptr, _F.INRS, _F.INTS))
    {
        // line 2233
        BOARD.RBTS = _F.INTS;
    }
    else
    {
        // line 2235
        BOARD.RBTS = C_AT;
    }

    // line 2236
    if((JNTM == C_DARK))
    {
        // line 2237
        BOARD.RBTI = (BOARD.RBTI + 1);
    }

    // line 2238
    _FOR_TO(_F.INTQ, C_LS, C_DL)
    {
        // line 2239
        if(F_INRSTB(nullptr, CSTAT[JNTK], XTQS[_F.INTQ]))
        {
            // line 2240
            {
                _T_GenericSet _setLiteral1;
                _setLiteral1.set(_F.INTQ);

                BOARD.RBSQ = (BOARD.RBSQ + _setLiteral1);
            }
        }
        else
        {
            // line 2242
            {
                _T_GenericSet _setLiteral2;
                _setLiteral2.set(_F.INTQ);

                BOARD.RBSQ = (BOARD.RBSQ - _setLiteral2);
            }
        }
    }
    _FOR_END(_F.INTQ)

    // line 2243
    _FOR_TO(_F.INTS, C_AS, C_ZS)
    {
        // line 2244
        BOARD.RBIS[_F.INTS] = MBORD[_F.INTS];
    }
    _FOR_END(_F.INTS)

    { /* NOP */ }

    { /* NOP */ }
}

// line 2249
//================================================================================
// scope: EVALU8 (level : 2)

// forward declarations
T_TV F_EVALU8_EVKING(void* _slink, T_RS A, T_RS B);
T_TV F_EVALU8_EVMOBL(void* _slink, T_TP A, T_TP B);
T_TV F_EVALU8_EVPAWN(void* _slink, T_RS A, T_TE B, T_TR C);
T_TV F_EVALU8_EVROOK(void* _slink, T_RS A, T_RS B);

// activation record
struct Frame_EVALU8
{
    // locals
    T_TV INTV;
};

// function body
void P_EVALU8(void* _slink)
{
    // prologue/frame definition
    Frame_EVALU8 _F = { };

    assert(nullptr == _slink);

    // subroutine body
    // line 2357
    if((((XTMV[JNTM] + MBVAL[JNTK]) + MAXPS) <= BSTVL[(JNTK - 2)]))
    {
        // line 2359
        _F.INTV = (XTMV[JNTM] + MBVAL[JNTK]);
    }
    else
    {
        // line 2362
        _F.INTV = ((((((FWPAWN * (F_EVALU8_EVPAWN(&_F, TPLOC[C_LP], C_S2, C_R2) - F_EVALU8_EVPAWN(&_F, TPLOC[C_DP], C_S4, C_R7))) + (FWMINM * (F_EVALU8_EVMOBL(&_F, C_LB, C_LN) - F_EVALU8_EVMOBL(&_F, C_DB, C_DN)))) + (FWMAJM * (F_EVALU8_EVMOBL(&_F, C_LR, C_LQ) - F_EVALU8_EVMOBL(&_F, C_DR, C_DQ)))) + (FWROOK * (F_EVALU8_EVROOK(&_F, TPLOC[C_LR], XRRS[C_R7]) - F_EVALU8_EVROOK(&_F, TPLOC[C_DR], XRRS[C_R2])))) + (FWKING * (F_EVALU8_EVKING(&_F, TPLOC[C_LK], TPLOC[C_LP]) - F_EVALU8_EVKING(&_F, TPLOC[C_DK], TPLOC[C_DP])))) / 64);

        // line 2370
        MAXPS = F_MAX(nullptr, MAXPS, _abs(_F.INTV));

        // line 2371
        _F.INTV = (XTMV[JNTM] * (MBVAL[JNTK] + _F.INTV));

        { /* NOP */ }
    }

    // line 2373
    if(SWTR)
    {
        // line 2375
        Output << " EVALU8" << JNTK << JNTW << INDEX[JNTK] << _F.INTV;

        // line 2376
        P_PRIMOV(nullptr, MOVES[INDEX[JNTK]]);

        { /* NOP */ }
    }

    // line 2378
    VALUE[INDEX[JNTK]] = _F.INTV;

    { /* NOP */ }
}

// line 2254
//================================================================================
// scope: EVALU8_EVKING (level : 3)

// activation record
struct Frame_EVALU8_EVKING
{
   Frame_EVALU8* _slink;

    // parameters
    T_RS A;
    T_RS B;

    // locals
    T_TV _fnvalue;
    T_RS INRS;
    T_TS INTS;
    T_TV INTV;
};

// function body
T_TV F_EVALU8_EVKING(void* _slink, T_RS A, T_RS B)
{
    // prologue/frame definition
    Frame_EVALU8_EVKING _F = { (Frame_EVALU8*)_slink, A, B };

    // subroutine body
    // line 2264
    P_ANDRS(nullptr, _F.INRS, _F.A, CORNR);

    // line 2265
    if(F_NULRS(nullptr, _F.INRS))
    {
        // line 2266
        _F.INTV = 0;
    }
    else
    {
        // line 2268
        _F.INTV = FKSANQ;
    }

    // line 2269
    _F.INRS = _F.A;

    // line 2270
    if(F_NXTTS(nullptr, _F.INRS, _F.INTS))
    {
        // line 2272
        P_ANDRS(nullptr, _F.INRS, ATKFR[_F.INTS], _F.B);

        // line 2273
        _F.INTV = (_F.INTV + (F_CNTRS(nullptr, _F.INRS) * FKPSHD));

        { /* NOP */ }
    }

    // line 2276
    _F._fnvalue = _F.INTV;

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2280
//================================================================================
// scope: EVALU8_EVMOBL (level : 3)

// activation record
struct Frame_EVALU8_EVMOBL
{
   Frame_EVALU8* _slink;

    // parameters
    T_TP A;
    T_TP B;

    // locals
    T_TV _fnvalue;
    T_RS INRS;
    T_TS INTS;
    T_TV INTV;
};

// function body
T_TV F_EVALU8_EVMOBL(void* _slink, T_TP A, T_TP B)
{
    // prologue/frame definition
    Frame_EVALU8_EVMOBL _F = { (Frame_EVALU8*)_slink, A, B };

    // subroutine body
    // line 2289
    P_IORRS(nullptr, _F.INRS, TPLOC[_F.A], TPLOC[_F.B]);

    // line 2290
    _F.INTV = 0;

    // line 2291
    while(F_NXTTS(nullptr, _F.INRS, _F.INTS))
    {
        // line 2292
        _F.INTV = (_F.INTV + F_CNTRS(nullptr, ATKFR[_F.INTS]));
    }

    // line 2293
    _F._fnvalue = _F.INTV;

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2297
//================================================================================
// scope: EVALU8_EVPAWN (level : 3)

// activation record
struct Frame_EVALU8_EVPAWN
{
   Frame_EVALU8* _slink;

    // parameters
    T_RS A;
    T_TE B;
    T_TR C;

    // locals
    T_TV _fnvalue;
    T_RS IMRS;
    T_RS INRS;
    T_TS INTS;
    T_TV INTV;
};

// function body
T_TV F_EVALU8_EVPAWN(void* _slink, T_RS A, T_TE B, T_TR C)
{
    // prologue/frame definition
    Frame_EVALU8_EVPAWN _F = { (Frame_EVALU8*)_slink, A, B, C };

    // subroutine body
    // line 2309
    P_SFTRS(nullptr, _F.INRS, _F.A, C_S1);

    // line 2310
    P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.A);

    // line 2311
    _F.INTV = (F_CNTRS(nullptr, _F.INRS) * FPFLNX);

    // line 2312
    P_SFTRS(nullptr, _F.INRS, _F.A, C_B1);

    // line 2313
    P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.A);

    // line 2314
    _F.INTV = (_F.INTV + (F_CNTRS(nullptr, _F.INRS) * FPCONN));

    // line 2315
    P_SFTRS(nullptr, _F.INRS, _F.A, C_B2);

    // line 2316
    P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.A);

    // line 2317
    _F.INTV = (_F.INTV + (F_CNTRS(nullptr, _F.INRS) * FPCONN));

    // line 2319
    P_SFTRS(nullptr, _F.INRS, _F.A, _F.B);

    // line 2320
    P_NOTRS(nullptr, _F.IMRS, TPLOC[C_MT]);

    // line 2321
    P_ANDRS(nullptr, _F.INRS, _F.INRS, _F.IMRS);

    // line 2322
    _F.INTV = (_F.INTV - (F_CNTRS(nullptr, _F.INRS) * FPBLOK));

    // line 2324
    P_CPYRS(nullptr, _F.INRS, _F.A);

    // line 2325
    while(F_NXTTS(nullptr, _F.IMRS, _F.INTS))
    {
        // line 2326
        _F.INTV = (_F.INTV + (_abs((_ord(_F.C) - _ord(XTSR[_F.INTS]))) * FPADCR[XTSF[_F.INTS]]));
    }

    // line 2328
    _F._fnvalue = _F.INTV;

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2332
//================================================================================
// scope: EVALU8_EVROOK (level : 3)

// activation record
struct Frame_EVALU8_EVROOK
{
   Frame_EVALU8* _slink;

    // parameters
    T_RS A;
    T_RS B;

    // locals
    T_TV _fnvalue;
    T_RS INRS;
    T_integer INTI;
    T_TS INTS;
    T_TV INTV;
};

// function body
T_TV F_EVALU8_EVROOK(void* _slink, T_RS A, T_RS B)
{
    // prologue/frame definition
    Frame_EVALU8_EVROOK _F = { (Frame_EVALU8*)_slink, A, B };

    // subroutine body
    // line 2343
    _F.INTV = 0;

    // line 2344
    _F.INRS = _F.A;

    // line 2345
    if(F_NXTTS(nullptr, _F.INRS, _F.INTS))
    {
        // line 2347
        P_ANDRS(nullptr, _F.INRS, _F.A, ATKFR[_F.INTS]);

        // line 2348
        if((!F_NULRS(nullptr, _F.INRS)))
        {
            // line 2349
            _F.INTV = (_F.INTV + FRDUBL);
        }

        { /* NOP */ }
    }

    // line 2351
    P_ANDRS(nullptr, _F.INRS, _F.A, _F.B);

    // line 2352
    _F.INTI = F_CNTRS(nullptr, _F.INRS);

    // line 2353
    _F._fnvalue = (_F.INTV + ((_F.INTI * _F.INTI) * FRK7TH));

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2382
//================================================================================
// scope: SEARCH (level : 2)

// forward declarations
void P_SEARCH_NEWBST(void* _slink, T_TK A);
T_boolean F_SEARCH_MINMAX(void* _slink, T_TK A);
void P_SEARCH_SCOREM(void* _slink);
T_boolean F_SEARCH_SELECT(void* _slink);

// activation record
struct Frame_SEARCH
{
    // locals
    T_TW _fnvalue;
    T_boolean Jumpin;
};

// function body
T_TW F_SEARCH(void* _slink)
{
    // prologue/frame definition
    Frame_SEARCH _F = { };

    assert(nullptr == _slink);

    // subroutine body
    // line 2669
    _F.Jumpin = C_false;

    // line 2670
    BSTMV[C_AK] = C_AW;

    // line 2671
    INDEX[JNTK] = C_AW;

    // line 2672
    MOVES[C_AW] = LSTMV;

    // line 2673
    P_EVALU8(nullptr);

    // line 2674
    BSTVL[(C_AK - 2)] = (VALUE[C_AW] - WINDOW);

    // line 2675
    BSTVL[(C_AK - 1)] = ((-VALUE[C_AW]) - WINDOW);

    // line 2676
    JMTK = (C_AK + 1);

    // line 2677
    while(((NODES < FNODEL) && (JNTK < F_MAX(nullptr, (C_ZK / 2), (C_ZK - 8)))))
    {
        // line 2681
        L_11:
        BSTVL[JNTK] = BSTVL[(JNTK - 2)];

        // line 2684
        L_12:
        if(((!F_SEARCH_SELECT(&_F)) && (!_F.Jumpin)))
        {
            // line 2686
            BSTVL[JNTK] = VALUE[INDEX[JNTK]];

            // line 2687
            P_SEARCH_NEWBST(&_F, JNTK);

            { /* NOP */ }
        }
        else
        {
            // line 2691
            if(_F.Jumpin)
            {
                // line 2691
                goto L_13;
            }

            // line 2692
            if(F_UPDATE(nullptr, MOVES[INDEX[(JNTK + 1)]]))
            {
                // line 2693
                goto L_11;
            }
            else
            {
                // line 2696
                P_DNDATE(nullptr, MOVES[INDEX[JNTK]]);

                // line 2697
                goto L_12;

                { /* NOP */ }
            }

            // line 2701
            L_13:
            _F.Jumpin = C_false;

            // line 2702
            if(F_SEARCH_MINMAX(&_F, JNTK))
            {
                // line 2703
                goto L_15;
            }

            // line 2706
            L_14:
            if(F_SEARCH_SELECT(&_F))
            {
                // line 2707
                if(F_UPDATE(nullptr, MOVES[INDEX[(JNTK + 1)]]))
                {
                    // line 2708
                    goto L_11;
                }
                else
                {
                    // line 2711
                    P_DNDATE(nullptr, MOVES[INDEX[JNTK]]);

                    // line 2712
                    goto L_14;

                    { /* NOP */ }
                }
            }

            { /* NOP */ }
        }

        // line 2717
        L_15:
        if((JNTK > C_AK))
        {
            // line 2719
            P_DNDATE(nullptr, MOVES[INDEX[JNTK]]);

            // line 2720
            _F.Jumpin = C_true;

            // line 2721
            goto L_12;

            { /* NOP */ }
        }

        // line 2725
        if(((BSTVL[C_AK] <= BSTVL[(C_AK - 2)]) || (BSTVL[C_AK] >= (-BSTVL[(C_AK - 1)]))))
        {
            // line 2727
            if((MVSEL[C_AK] == 0))
            {
                // line 2729
                goto L_16;

                { /* NOP */ }
            }

            // line 2731
            BSTVL[(C_AK - 2)] = (-C_ZV);

            // line 2732
            BSTVL[(C_AK - 1)] = (-C_ZV);

            // line 2733
            SRCHM[C_AK] = C_H7;

            // line 2734
            JNTW = (C_AK + 1);

            // line 2735
            goto L_11;

            { /* NOP */ }
        }

        // line 2737
        BSTVL[(C_AK - 2)] = (BSTVL[C_AK] - WINDOW);

        // line 2738
        BSTVL[(C_AK - 1)] = ((-BSTVL[C_AK]) - WINDOW);

        // line 2739
        JMTK = (JMTK + 1);

        // line 2740
        SRCHM[C_AK] = C_H7;

        { /* NOP */ }
    }

    // line 2744
    L_16:
    _F._fnvalue = BSTMV[C_AK];

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2395
//================================================================================
// scope: SEARCH_NEWBST (level : 3)

// activation record
struct Frame_SEARCH_NEWBST
{
   Frame_SEARCH* _slink;

    // parameters
    T_TK A;

    // locals
    T_RM INRM;
    T_TW INTW;
};

// function body
void P_SEARCH_NEWBST(void* _slink, T_TK A)
{
    // prologue/frame definition
    Frame_SEARCH_NEWBST _F = { (Frame_SEARCH*)_slink, A };

    // subroutine body
    // line 2403
    BSTMV[_F.A] = INDEX[(_F.A + 1)];

    // line 2404
    if((_F.A == C_AK))
    {
        // line 2406
        _F.INRM = MOVES[BSTMV[_F.A]];

        // line 2407
        _FOR_DOWNTO(_F.INTW, (BSTMV[_F.A] - 1), (C_AW + 1))
        {
            // line 2408
            MOVES[(_F.INTW + 1)] = MOVES[_F.INTW];
        }
        _FOR_END(_F.INTW)

        // line 2409
        MOVES[(C_AW + 1)] = _F.INRM;

        // line 2410
        BSTMV[C_AK] = (C_AW + 1);

        { /* NOP */ }
    }
    else
    {
        // line 2413
        if((!MOVES[BSTMV[_F.A]].RMCA))
        {
            // line 2414
            KILLR[JNTK] = MOVES[BSTMV[_F.A]];
        }
    }

    { /* NOP */ }
}

// line 2418
//================================================================================
// scope: SEARCH_MINMAX (level : 3)

// activation record
struct Frame_SEARCH_MINMAX
{
   Frame_SEARCH* _slink;

    // parameters
    T_TK A;

    // locals
    T_boolean _fnvalue;
};

// function body
T_boolean F_SEARCH_MINMAX(void* _slink, T_TK A)
{
    // prologue/frame definition
    Frame_SEARCH_MINMAX _F = { (Frame_SEARCH*)_slink, A };

    // subroutine body
    // line 2423
    _F._fnvalue = C_false;

    // line 2424
    if(SWTR)
    {
        // line 2425
        Output << " MINMAX" << _F.A << (-BSTVL[(_F.A - 1)]) << BSTVL[_F.A] << (-BSTVL[(_F.A + 1)]);
    }

    // line 2426
    if(((-BSTVL[(_F.A + 1)]) > BSTVL[_F.A]))
    {
        // line 2428
        BSTVL[_F.A] = (-BSTVL[(_F.A + 1)]);

        // line 2429
        P_SEARCH_NEWBST(_F._slink, _F.A);

        // line 2430
        _F._fnvalue = (BSTVL[(_F.A + 1)] <= BSTVL[(_F.A - 1)]);

        // line 2432
        if(SWTR)
        {
            // line 2433
            Output << " NEW BEST. PRUNE: " << _str((BSTVL[(_F.A + 1)] <= BSTVL[(_F.A - 1)]));
        }

        { /* NOP */ }
    }

    // line 2435
    if(SWTR)
    {
        // line 2436
        Output << _WRITELN;
    }

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2440
//================================================================================
// scope: SEARCH_SCOREM (level : 3)

// activation record
struct Frame_SEARCH_SCOREM
{
   Frame_SEARCH* _slink;
};

// function body
void P_SEARCH_SCOREM(void* _slink)
{
    // prologue/frame definition
    Frame_SEARCH_SCOREM _F = { (Frame_SEARCH*)_slink };

    // subroutine body
    // line 2443
    MOVES[INDEX[JNTK]].RMMT = C_true;

    // line 2444
    if(MOVES[INDEX[JNTK]].RMCH)
    {
        // line 2445
        VALUE[INDEX[JNTK]] = ((64 * JNTK) - C_ZV);
    }
    else
    {
        // line 2447
        VALUE[INDEX[JNTK]] = 0;
    }

    // line 2448
    if(SWTR)
    {
        // line 2449
        Output << " SCOREM" << JNTK << JNTW << INDEX[JNTK] << VALUE[INDEX[JNTK]] << _WRITELN;
    }

    { /* NOP */ }
}

// line 2453
//================================================================================
// scope: SEARCH_SELECT (level : 3)

// forward declarations
void P_SEARCH_SELECT_SELDON(void* _slink);
void P_SEARCH_SELECT_SELMOV(void* _slink, T_TW A);
void P_SEARCH_SELECT_SELNXT(void* _slink, T_TH A);
void P_SEARCH_SELECT_SELANY(void* _slink);

// non-local goto targets
const int NL_SEARCH_SELECT_21 = 2;
const int NL_SEARCH_SELECT_22 = 1;

// activation record
struct Frame_SEARCH_SELECT
{
   Frame_SEARCH* _slink;

    // locals
    T_boolean _fnvalue;
    T_TW IMTW;
    T_boolean INTB;
    T_TK INTK;
    T_TV INTV;
    T_TW INTW;
};

// function body
T_boolean F_SEARCH_SELECT(void* _slink)
{
    // prologue/frame definition
    Frame_SEARCH_SELECT _F = { (Frame_SEARCH*)_slink };

    int _nonlocalTarget = 0;

    _nonlocalGoto:
    try
    {
        switch(_nonlocalTarget)
        {
        case 0: break;
        case NL_SEARCH_SELECT_21: goto L_21;
        case NL_SEARCH_SELECT_22: goto L_22;
        default: _RTError("unexpected non-local target");
        }

        // subroutine body
        // line 2528
        L_21:
        switch(SRCHM[JNTK])
        {
        case C_H0:
            // line 2532
            MVSEL[JNTK] = 0;

            // line 2533
            _F.INTV = BSTVL[(JNTK - 2)];

            // line 2534
            BSTVL[(JNTK - 2)] = (-C_ZV);

            // line 2535
            MAXPS = 0;

            // line 2537
            P_GENALL(nullptr);

            // line 2538
            _FOR_TO(_F.INTW, (C_AW + 1), (JNTW - 1))
            {
                // line 2540
                if(F_UPDATE(nullptr, MOVES[_F.INTW]))
                {
                    // line 2542
                    INDEX[JNTK] = _F.INTW;

                    // line 2543
                    P_EVALU8(nullptr);

                    { /* NOP */ }
                }

                // line 2545
                P_DNDATE(nullptr, MOVES[_F.INTW]);

                { /* NOP */ }
            }
            _FOR_END(_F.INTW)

            // line 2547
            BSTVL[(JNTK - 2)] = _F.INTV;

            // line 2548
            P_SORTIT(nullptr, VALUE, MOVES, T_TW::C((JNTW - 1)));

            // line 2550
            _FOR_TO(_F.INTK, C_AK, C_ZK)
            {
                // line 2551
                KILLR[_F.INTK] = NULMV;
            }
            _FOR_END(_F.INTK)

            // line 2552
            if((SWTR || SWPS))
            {
                // line 2553
                _FOR_TO(_F.INTW, (C_AW + 1), (JNTW - 1))
                {
                    // line 2555
                    Output << " PRELIM" << _F.INTW << VALUE[_F.INTW];

                    // line 2556
                    P_PRIMOV(nullptr, MOVES[_F.INTW]);

                    // line 2557
                    if((((double)_F.INTW / C_LPP) == (_F.INTW / C_LPP)))
                    {
                        // line 2558
                        P_PAUSER(nullptr);
                    }

                    { /* NOP */ }
                }
                _FOR_END(_F.INTW)
            }

            // line 2560
            P_SEARCH_SELECT_SELNXT(&_F, C_H6);

            { /* NOP */ }
            break;

        case C_H1:
            // line 2565
            MVSEL[JNTK] = 0;

            // line 2566
            if((JNTK > JMTK))
            {
                // line 2568
                P_EVALU8(nullptr);

                // line 2569
                INDEX[(JNTK + 1)] = C_AW;

                // line 2570
                BSTVL[(JNTK + 1)] = (-VALUE[INDEX[JNTK]]);

                // line 2571
                if((F_SEARCH_MINMAX(_F._slink, JNTK) || (JNTK == C_ZK)))
                {
                    // line 2572
                    P_SEARCH_SELECT_SELDON(&_F);
                }

                // line 2573
                SRCHM[JNTK] = C_H2;

                { /* NOP */ }
            }
            else
            {
                // line 2576
                SRCHM[JNTK] = C_H3;
            }

            // line 2577
            P_GENCAP(nullptr);

            // line 2578
            P_SEARCH_SELECT_SELNXT(&_F, SRCHM[JNTK]);

            { /* NOP */ }
            break;

        case C_H2:
            // line 2583
            _F.INTW = C_AW;

            // line 2584
            _F.INTV = C_AV;

            // line 2585
            _FOR_TO(_F.IMTW, LINDX[JNTK], (JNTW - 1))
            {
                // line 2587
                if((!MOVES[_F.IMTW].RMSU))
                {
                    // line 2588
                    if((_abs(XTPV[MOVES[_F.IMTW].RMCP]) > _F.INTV))
                    {
                        // line 2590
                        _F.INTV = _abs(XTPV[MOVES[_F.IMTW].RMCP]);

                        // line 2591
                        _F.INTW = _F.IMTW;

                        { /* NOP */ }
                    }
                }
            }
            _FOR_END(_F.IMTW)

            // line 2593
            if((_F.INTW != C_AW))
            {
                // line 2594
                P_SEARCH_SELECT_SELMOV(&_F, _F.INTW);
            }
            else
            {
                // line 2596
                P_SEARCH_SELECT_SELDON(&_F);
            }

            { /* NOP */ }
            break;

        case C_H3:
            // line 2601
            _F.INTW = C_AW;

            // line 2602
            _F.INTV = C_AV;

            // line 2603
            _FOR_TO(_F.IMTW, LINDX[JNTK], (JNTW - 1))
            {
                // line 2605
                if((!MOVES[_F.IMTW].RMSU))
                {
                    // line 2606
                    if((_abs(XTPV[MOVES[_F.IMTW].RMCP]) > _F.INTV))
                    {
                        // line 2608
                        _F.INTV = _abs(XTPV[MOVES[_F.IMTW].RMCP]);

                        // line 2609
                        _F.INTW = _F.IMTW;

                        { /* NOP */ }
                    }
                }
            }
            _FOR_END(_F.IMTW)

            // line 2611
            if((_F.INTW != C_AW))
            {
                // line 2612
                P_SEARCH_SELECT_SELMOV(&_F, _F.INTW);
            }
            else
            {
                // line 2614
                if((!F_NULMVB(nullptr, KILLR[JNTK])))
                {
                    // line 2616
                    _F.IMTW = JNTW;

                    // line 2617
                    P_GENFSL(nullptr, XRSS[KILLR[JNTK].RMFR]);

                    // line 2619
                    SRCHM[JNTK] = C_H4;

                    // line 2620
                    _FOR_TO(_F.INTW, _F.IMTW, (JNTW - 1))
                    {
                        // line 2622
                        if((KILLR[JNTK].RMTO == MOVES[_F.INTW].RMTO))
                        {
                            // line 2623
                            P_SEARCH_SELECT_SELMOV(&_F, _F.INTW);
                        }
                    }
                    _FOR_END(_F.INTW)

                    { /* NOP */ }
                }
            }

            // line 2625
            P_SEARCH_SELECT_SELNXT(&_F, C_H4);

            { /* NOP */ }
            break;

        case C_H4:
            // line 2631
            P_GENCAS(nullptr);

            // line 2632
            P_SEARCH_SELECT_SELNXT(&_F, C_H5);

            { /* NOP */ }
            break;

        case C_H5:
            // line 2638
            P_SEARCH_SELECT_SELANY(&_F);

            // line 2639
            P_GENFSL(nullptr, ALLOC[JNTK]);

            // line 2640
            P_SEARCH_SELECT_SELNXT(&_F, C_H6);

            { /* NOP */ }
            break;

        case C_H6:
            // line 2645
            P_SEARCH_SELECT_SELANY(&_F);

            // line 2646
            if((MVSEL[JNTK] == 0))
            {
                // line 2647
                P_SEARCH_SCOREM(_F._slink);
            }

            // line 2648
            P_SEARCH_SELECT_SELDON(&_F);

            { /* NOP */ }
            break;

        case C_H7:
            // line 2653
            JNTW = LINDX[(C_AK + 1)];

            // line 2654
            MVSEL[C_AK] = 0;

            // line 2655
            _FOR_TO(_F.INTW, (C_AW + 1), (JNTW - 1))
            {
                // line 2656
                MOVES[_F.INTW].RMSU = C_false;
            }
            _FOR_END(_F.INTW)

            // line 2658
            if(SWTR)
            {
                // line 2659
                Output << " REDO " << JNTK << BSTVL[(C_AK - 2)] << BSTVL[(C_AK - 1)] << _WRITELN;
            }

            // line 2660
            P_SEARCH_SELECT_SELNXT(&_F, C_H6);

            { /* NOP */ }
            break;
        }

        // line 2665
        L_22:
        _F._fnvalue = _F.INTB;

        { /* NOP */ }

        // epilogue
        return _F._fnvalue;
    }
    catch(int _target)
    {
        switch(_target)
        {
        case NL_SEARCH_SELECT_21:
        case NL_SEARCH_SELECT_22:
            _nonlocalTarget = _target;
            goto _nonlocalGoto;
        default: throw;
        }
    }
}

// line 2467
//================================================================================
// scope: SEARCH_SELECT_SELDON (level : 4)

// activation record
struct Frame_SEARCH_SELECT_SELDON
{
   Frame_SEARCH_SELECT* _slink;
};

// function body
void P_SEARCH_SELECT_SELDON(void* _slink)
{
    // prologue/frame definition
    Frame_SEARCH_SELECT_SELDON _F = { (Frame_SEARCH_SELECT*)_slink };

    // subroutine body
    // line 2475
    _F._slink->INTB = C_false;

    // line 2476
    if(SWTR)
    {
        // line 2477
        Output << " SELECT" << JNTK << " END." << _WRITELN;
    }

    // line 2478
    throw NL_SEARCH_SELECT_22;

    { /* NOP */ }
}

// line 2482
//================================================================================
// scope: SEARCH_SELECT_SELMOV (level : 4)

// activation record
struct Frame_SEARCH_SELECT_SELMOV
{
   Frame_SEARCH_SELECT* _slink;

    // parameters
    T_TW A;
};

// function body
void P_SEARCH_SELECT_SELMOV(void* _slink, T_TW A)
{
    // prologue/frame definition
    Frame_SEARCH_SELECT_SELMOV _F = { (Frame_SEARCH_SELECT*)_slink, A };

    // subroutine body
    // line 2489
    _F._slink->INTB = C_true;

    // line 2490
    INDEX[(JNTK + 1)] = _F.A;

    // line 2491
    MOVES[_F.A].RMSU = C_true;

    // line 2492
    if(SWTR)
    {
        // line 2494
        Output << " SELECT" << JNTK << _ord(SRCHM[JNTK]) << _F.A;

        // line 2495
        P_PRIMOV(nullptr, MOVES[_F.A]);

        { /* NOP */ }
    }

    // line 2497
    throw NL_SEARCH_SELECT_22;

    { /* NOP */ }
}

// line 2501
//================================================================================
// scope: SEARCH_SELECT_SELNXT (level : 4)

// activation record
struct Frame_SEARCH_SELECT_SELNXT
{
   Frame_SEARCH_SELECT* _slink;

    // parameters
    T_TH A;
};

// function body
void P_SEARCH_SELECT_SELNXT(void* _slink, T_TH A)
{
    // prologue/frame definition
    Frame_SEARCH_SELECT_SELNXT _F = { (Frame_SEARCH_SELECT*)_slink, A };

    // subroutine body
    // line 2507
    INDEX[(JNTK + 1)] = (LINDX[JNTK] - 1);

    // line 2508
    SRCHM[JNTK] = _F.A;

    // line 2509
    throw NL_SEARCH_SELECT_21;

    { /* NOP */ }
}

// line 2513
//================================================================================
// scope: SEARCH_SELECT_SELANY (level : 4)

// activation record
struct Frame_SEARCH_SELECT_SELANY
{
   Frame_SEARCH_SELECT* _slink;

    // locals
    T_TW INTW;
};

// function body
void P_SEARCH_SELECT_SELANY(void* _slink)
{
    // prologue/frame definition
    Frame_SEARCH_SELECT_SELANY _F = { (Frame_SEARCH_SELECT*)_slink };

    // subroutine body
    // line 2520
    _FOR_TO(_F.INTW, (INDEX[(JNTK + 1)] + 1), (JNTW - 1))
    {
        // line 2521
        if((!MOVES[_F.INTW].RMSU))
        {
            // line 2522
            P_SEARCH_SELECT_SELMOV(_F._slink, _F.INTW);
        }
    }
    _FOR_END(_F.INTW)

    { /* NOP */ }
}

// line 2748
//================================================================================
// scope: READER (level : 2)

// types
typedef _T_Pfn<void (*)(void*)> T_READER_subroutine_46;

// forward declarations
void P_READER_RDRERR(void* _slink, T_RN A);
T_boolean F_READER_RDRGNT(void* _slink, T_RA& A);
void P_READER_RDRSFT(void* _slink);
void P_READER_RDRCMD(void* _slink, T_RA A, T_READER_subroutine_46 XXXCMD);
void P_READER_RDLINE(void* _slink);
T_boolean F_READER_RDRMOV(void* _slink);
T_integer F_READER_RDRNUM(void* _slink);
void P_READER_BOACMD(void* _slink);
void P_READER_ENDCMD(void* _slink);
void P_READER_GONCMD(void* _slink);
void P_READER_INICMD(void* _slink);
void P_READER_LETCMD(void* _slink);
void P_READER_PLECMD(void* _slink);
void P_READER_PRICMD(void* _slink);
void P_READER_PAMCMD(void* _slink);
void P_READER_POPCMD(void* _slink);
void P_READER_PMVCMD(void* _slink);
void P_READER_SWICMD(void* _slink);
void P_READER_STACMD(void* _slink);
void P_READER_WHACMD(void* _slink);

// non-local goto targets
const int NL_READER_11 = 3;

// activation record
struct Frame_READER
{
    // locals
    T_RA INRA;
    T_TJ INTJ;
};

// function body
void P_READER(void* _slink)
{
    // prologue/frame definition
    Frame_READER _F = { };

    assert(nullptr == _slink);

    // hoisted definitions
    _T_GenericSet _setLiteral1;
    _setLiteral1.set('A', 'W');
    _setLiteral1.set('Y');
    _setLiteral1.set('Z');

    int _nonlocalTarget = 0;

    _nonlocalGoto:
    try
    {
        switch(_nonlocalTarget)
        {
        case 0: break;
        case NL_READER_11: goto L_11;
        default: _RTError("unexpected non-local target");
        }

        // subroutine body
        // line 3377
        L_11:
        while((!F_READER_RDRMOV(&_F)))
        {
            // line 3378
            P_READER_RDLINE(&_F);
        }

        // line 3379
        if(SWEC)
        {
            // line 3381
            Output << ' ';

            // line 3382
            _FOR_TO(_F.INTJ, C_AJ, (C_ZJ - 1))
            {
                // line 3383
                Output << ILINE[_F.INTJ];
            }
            _FOR_END(_F.INTJ)

            // line 3384
            Output << ' ' << _WRITELN;

            { /* NOP */ }
        }

        // line 3386
        if((_setLiteral1 & ILINE[(C_AJ + 1)]))
        {
            // line 3388
            _F.INRA = "          ";

            // line 3389
            _F.INRA[C_AA] = ILINE[C_AJ];

            // line 3390
            _F.INRA[(C_AA + 1)] = ILINE[(C_AJ + 1)];

            // line 3391
            P_READER_RDRSFT(&_F);

            // line 3392
            P_READER_RDRCMD(&_F, T_RA::C("BO        "), _makePfn(P_READER_BOACMD, &_F));

            // line 3393
            P_READER_RDRCMD(&_F, T_RA::C("EN        "), _makePfn(P_READER_ENDCMD, &_F));

            // line 3394
            P_READER_RDRCMD(&_F, T_RA::C("GO        "), _makePfn(P_READER_GONCMD, &_F));

            // line 3395
            P_READER_RDRCMD(&_F, T_RA::C("IN        "), _makePfn(P_READER_INICMD, &_F));

            // line 3396
            P_READER_RDRCMD(&_F, T_RA::C("LE        "), _makePfn(P_READER_LETCMD, &_F));

            // line 3397
            P_READER_RDRCMD(&_F, T_RA::C("PB        "), _makePfn(P_READER_PAMCMD, &_F));

            // line 3398
            P_READER_RDRCMD(&_F, T_RA::C("PO        "), _makePfn(P_READER_POPCMD, &_F));

            // line 3399
            P_READER_RDRCMD(&_F, T_RA::C("PL        "), _makePfn(P_READER_PLECMD, &_F));

            // line 3400
            P_READER_RDRCMD(&_F, T_RA::C("PM        "), _makePfn(P_READER_PMVCMD, &_F));

            // line 3401
            P_READER_RDRCMD(&_F, T_RA::C("PR        "), _makePfn(P_READER_PRICMD, &_F));

            // line 3402
            P_READER_RDRCMD(&_F, T_RA::C("ST        "), _makePfn(P_READER_STACMD, &_F));

            // line 3403
            P_READER_RDRCMD(&_F, T_RA::C("SW        "), _makePfn(P_READER_SWICMD, &_F));

            // line 3404
            P_READER_RDRCMD(&_F, T_RA::C("WH        "), _makePfn(P_READER_WHACMD, &_F));

            // line 3405
            P_READER_RDRERR(&_F, T_RN::C("* IMWALID COMMAND             "));

            { /* NOP */ }
        }

        { /* NOP */ }
    }
    catch(int _target)
    {
        switch(_target)
        {
        case NL_READER_11:
            _nonlocalTarget = _target;
            goto _nonlocalGoto;
        default: throw;
        }
    }
}

// line 2757
//================================================================================
// scope: READER_RDRERR (level : 3)

// activation record
struct Frame_READER_RDRERR
{
   Frame_READER* _slink;

    // parameters
    T_RN A;

    // locals
    T_TJ INTJ;
    T_TN INTN;
};

// function body
void P_READER_RDRERR(void* _slink, T_RN A)
{
    // prologue/frame definition
    Frame_READER_RDRERR _F = { (Frame_READER*)_slink, A };

    // subroutine body
    // line 2764
    if((!SWEC))
    {
        // line 2767
        Output << ' ';

        // line 2768
        _FOR_TO(_F.INTJ, C_AJ, (C_ZJ - 1))
        {
            // line 2769
            Output << ILINE[_F.INTJ];
        }
        _FOR_END(_F.INTJ)

        // line 2770
        Output << ' ' << _WRITELN;

        { /* NOP */ }
    }

    // line 2772
    _FOR_TO(_F.INTJ, C_AJ, JNTJ)
    {
        // line 2773
        Output << ' ';
    }
    _FOR_END(_F.INTJ)

    // line 2774
    Output << '^' << _WRITELN;

    // line 2775
    _FOR_TO(_F.INTN, C_AN, C_ZN)
    {
        // line 2776
        Output << _F.A[_F.INTN];
    }
    _FOR_END(_F.INTN)

    // line 2777
    Output << _WRITELN;

    // line 2778
    throw NL_READER_11;

    { /* NOP */ }
}

// line 2782
//================================================================================
// scope: READER_RDRGNT (level : 3)

// activation record
struct Frame_READER_RDRGNT
{
   Frame_READER* _slink;

    // parameters
    T_RA& A;

    // locals
    T_boolean _fnvalue;
    T_TJ INTJ;
};

// function body
T_boolean F_READER_RDRGNT(void* _slink, T_RA& A)
{
    // prologue/frame definition
    Frame_READER_RDRGNT _F = { (Frame_READER*)_slink, A };

    // hoisted definitions
    _T_GenericSet _setLiteral1;
    _setLiteral1.set('A', 'Z');
    _setLiteral1.set('0', '9');

    _T_GenericSet _setLiteral2;
    _setLiteral2.set('A', 'Z');
    _setLiteral2.set('0', '9');

    // subroutine body
    // line 2796
    while(((JNTJ < C_ZJ) && (_ord(ILINE[JNTJ]) >= _ord('+'))))
    {
        // line 2797
        JNTJ = (JNTJ + 1);
    }

    // line 2798
    _F.A = "          ";

    // line 2799
    _F.INTJ = C_AA;

    // line 2800
    while((((JNTJ < C_ZJ) && (_F.INTJ < C_ZA)) && (_setLiteral1 & ILINE[JNTJ])))
    {
        // line 2802
        _F.A[_F.INTJ] = ILINE[JNTJ];

        // line 2803
        _F.INTJ = (_F.INTJ + 1);

        // line 2804
        JNTJ = (JNTJ + 1);

        { /* NOP */ }
    }

    // line 2806
    _F._fnvalue = (_F.INTJ != C_AA);

    // line 2807
    while((((_F.INTJ < C_ZJ) && (JNTJ < C_ZJ)) && (_setLiteral2 & ILINE[JNTJ])))
    {
        // line 2808
        JNTJ = (JNTJ + 1);
    }

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2812
//================================================================================
// scope: READER_RDRSFT (level : 3)

// activation record
struct Frame_READER_RDRSFT
{
   Frame_READER* _slink;

    // locals
    T_RA INRA;
    T_boolean INTB;
};

// function body
void P_READER_RDRSFT(void* _slink)
{
    // prologue/frame definition
    Frame_READER_RDRSFT _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 2820
    JNTJ = C_AJ;

    // line 2821
    _F.INTB = F_READER_RDRGNT(_F._slink, _F.INRA);

    { /* NOP */ }
}

// line 2825
//================================================================================
// scope: READER_RDRCMD (level : 3)

// activation record
struct Frame_READER_RDRCMD
{
   Frame_READER* _slink;

    // parameters
    T_RA A;
    T_READER_subroutine_46 XXXCMD;
};

// function body
void P_READER_RDRCMD(void* _slink, T_RA A, T_READER_subroutine_46 XXXCMD)
{
    // prologue/frame definition
    Frame_READER_RDRCMD _F = { (Frame_READER*)_slink, A, XXXCMD };

    // subroutine body
    // line 2832
    if(_strcmpEQ<10>(_F._slink->INRA, _F.A))
    {
        // line 2834
        (*_F.XXXCMD._pfn)(_F.XXXCMD._slink);

        // line 2835
        throw NL_READER_11;

        { /* NOP */ }
    }

    { /* NOP */ }
}

// line 2840
//================================================================================
// scope: READER_RDLINE (level : 3)

// activation record
struct Frame_READER_RDLINE
{
   Frame_READER* _slink;

    // locals
    T_char INTC;
    T_TJ INTJ;
};

// function body
void P_READER_RDLINE(void* _slink)
{
    // prologue/frame definition
    Frame_READER_RDLINE _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 2848
    Input >> _READLN;

    // line 2849
    _F.INTJ = C_AJ;

    // line 2850
    while(((!_eoln(Input)) && (_F.INTJ < C_ZJ)))
    {
        // line 2852
        Input >> ICARD[_F.INTJ];

        // line 2853
        _F.INTJ = (_F.INTJ + 1);

        { /* NOP */ }
    }

    // line 2855
    while((!_eoln(Input)))
    {
        // line 2856
        Input >> _F.INTC;
    }

    // line 2857
    while((_F.INTJ < C_ZJ))
    {
        // line 2859
        ICARD[_F.INTJ] = ' ';

        // line 2860
        _F.INTJ = (_F.INTJ + 1);

        { /* NOP */ }
    }

    // line 2862
    ICARD[C_ZJ] = ';';

    // line 2863
    JMTJ = C_AJ;

    { /* NOP */ }
}

// line 2867
//================================================================================
// scope: READER_RDRMOV (level : 3)

// activation record
struct Frame_READER_RDRMOV
{
   Frame_READER* _slink;

    // locals
    T_boolean _fnvalue;
    T_TJ IMTJ;
};

// function body
T_boolean F_READER_RDRMOV(void* _slink)
{
    // prologue/frame definition
    Frame_READER_RDRMOV _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 2876
    while(((JMTJ < C_ZJ) && (ICARD[JMTJ] == ' ')))
    {
        // line 2877
        JMTJ = (JMTJ + 1);
    }

    // line 2878
    _F.IMTJ = C_AJ;

    // line 2879
    while(((JMTJ < C_ZJ) && (ICARD[JMTJ] != ';')))
    {
        // line 2881
        ILINE[_F.IMTJ] = ICARD[JMTJ];

        // line 2882
        _F.IMTJ = (_F.IMTJ + 1);

        // line 2883
        JMTJ = (JMTJ + 1);

        { /* NOP */ }
    }

    // line 2885
    if(((ICARD[JMTJ] == ';') && (JMTJ < C_ZJ)))
    {
        // line 2886
        JMTJ = (JMTJ + 1);
    }

    // line 2887
    _F._fnvalue = (_F.IMTJ != C_AJ);

    // line 2888
    while((_F.IMTJ < C_ZJ))
    {
        // line 2890
        ILINE[_F.IMTJ] = ' ';

        // line 2891
        _F.IMTJ = (_F.IMTJ + 1);

        { /* NOP */ }
    }

    // line 2893
    ILINE[C_ZJ] = ';';

    // line 2894
    JNTJ = C_AJ;

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2898
//================================================================================
// scope: READER_RDRNUM (level : 3)

// activation record
struct Frame_READER_RDRNUM
{
   Frame_READER* _slink;

    // locals
    T_integer _fnvalue;
    T_boolean INTB;
    T_integer INTI;
};

// function body
T_integer F_READER_RDRNUM(void* _slink)
{
    // prologue/frame definition
    Frame_READER_RDRNUM _F = { (Frame_READER*)_slink };

    // hoisted definitions
    _T_GenericSet _setLiteral1;
    _setLiteral1.set('0', '9');

    _T_GenericSet _setLiteral2;
    _setLiteral2.set('A', 'Z');

    // subroutine body
    // line 2908
    while(((JNTJ < C_ZJ) && (ILINE[JNTJ] == ' ')))
    {
        // line 2909
        JNTJ = (JNTJ + 1);
    }

    // line 2910
    if((ILINE[JNTJ] == '-'))
    {
        // line 2912
        _F.INTB = C_true;

        // line 2913
        JNTJ = (JNTJ + 1);

        { /* NOP */ }
    }
    else
    {
        // line 2917
        _F.INTB = C_false;

        // line 2918
        if((ILINE[JNTJ] == '+'))
        {
            // line 2919
            JNTJ = (JNTJ + 1);
        }

        { /* NOP */ }
    }

    // line 2921
    _F.INTI = 0;

    // line 2922
    while((_setLiteral1 & ILINE[JNTJ]))
    {
        // line 2924
        if((_F.INTI < ((double)C_maxint / 10)))
        {
            // line 2925
            _F.INTI = (((10 * _F.INTI) + _ord(ILINE[JNTJ])) - _ord('0'));
        }
        else
        {
            // line 2927
            P_READER_RDRERR(_F._slink, T_RN::C(" NUMBER TOO LARGE             "));
        }

        // line 2928
        JNTJ = (JNTJ + 1);

        { /* NOP */ }
    }

    // line 2930
    if((_setLiteral2 & ILINE[JNTJ]))
    {
        // line 2931
        P_READER_RDRERR(_F._slink, T_RN::C(" DIGIT EXPECTED               "));
    }

    // line 2932
    if(_F.INTB)
    {
        // line 2933
        _F.INTI = (-_F.INTI);
    }

    // line 2934
    _F._fnvalue = _F.INTI;

    { /* NOP */ }

    // epilogue
    return _F._fnvalue;
}

// line 2938
//================================================================================
// scope: READER_BOACMD (level : 3)

// forward declarations
void P_READER_BOACMD_BOAADV(void* _slink, T_integer A);
void P_READER_BOACMD_BOASTO(void* _slink, T_TP A);

// activation record
struct Frame_READER_BOACMD
{
   Frame_READER* _slink;

    // locals
    T_TM INTM;
    T_TS INTS;
    T_TS INTS1;
};

// function body
void P_READER_BOACMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_BOACMD _F = { (Frame_READER*)_slink };

    // hoisted definitions
    _T_GenericSet _setLiteral1;
    _setLiteral1.set('P');
    _setLiteral1.set('R');
    _setLiteral1.set('N');
    _setLiteral1.set('B');
    _setLiteral1.set('Q');
    _setLiteral1.set('K');
    _setLiteral1.set('L');
    _setLiteral1.set('D');
    _setLiteral1.set('1', '8');

    _T_GenericSet _setLiteral2;
    _setLiteral2.set('A', 'Z');
    _setLiteral2.set('0', '9');

    // subroutine body
    // line 2964
    P_CLSTAT(nullptr);

    // line 2965
    LSTMV = NULMV;

    // line 2966
    _FOR_TO(_F.INTS1, C_AS, C_ZS)
    {
        // line 2967
        BOARD.RBIS[_F.INTS1] = C_MT;
    }
    _FOR_END(_F.INTS1)

    // line 2968
    _F.INTM = C_LITE;

    // line 2969
    _F.INTS = 0;

    // line 2970
    do
    {
        // line 2971
        if((_setLiteral1 & ILINE[JNTJ]))
        {
            // line 2972
            switch(ILINE[JNTJ])
            {
            case 'P':
                // line 2973
                P_READER_BOACMD_BOASTO(&_F, XTUMP[C_EP][_F.INTM]);
                break;

            case 'R':
                // line 2974
                P_READER_BOACMD_BOASTO(&_F, XTUMP[C_ER][_F.INTM]);
                break;

            case 'N':
                // line 2975
                P_READER_BOACMD_BOASTO(&_F, XTUMP[C_EN][_F.INTM]);
                break;

            case 'B':
                // line 2976
                P_READER_BOACMD_BOASTO(&_F, XTUMP[C_EB][_F.INTM]);
                break;

            case 'Q':
                // line 2977
                P_READER_BOACMD_BOASTO(&_F, XTUMP[C_EQ][_F.INTM]);
                break;

            case 'K':
                // line 2978
                P_READER_BOACMD_BOASTO(&_F, XTUMP[C_EK][_F.INTM]);
                break;

            case 'L':
                // line 2979
                _F.INTM = C_LITE;
                break;

            case 'D':
                // line 2980
                _F.INTM = C_DARK;
                break;

            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
                // line 2981
                P_READER_BOACMD_BOAADV(&_F, (_ord(ILINE[JNTJ]) - _ord('0')));
                break;
            }
        }
        else
        {
            // line 2984
            if((_setLiteral2 & ILINE[JNTJ]))
            {
                // line 2986
                _FOR_TO(_F.INTS1, C_AS, C_ZS)
                {
                    // line 2987
                    BOARD.RBIS[_F.INTS1] = C_MT;
                }
                _FOR_END(_F.INTS1)

                // line 2988
                P_CLSTAT(nullptr);

                // line 2989
                P_READER_RDRERR(_F._slink, T_RN::C(" ILLEGAL BOARD OPTION         "));

                { /* NOP */ }
            }
        }

        // line 2991
        JNTJ = (JNTJ + 1);

        { /* NOP */ }
    }
    while(!(JNTJ == C_ZJ));

    { /* NOP */ }
}

// line 2946
//================================================================================
// scope: READER_BOACMD_BOAADV (level : 4)

// activation record
struct Frame_READER_BOACMD_BOAADV
{
   Frame_READER_BOACMD* _slink;

    // parameters
    T_integer A;
};

// function body
void P_READER_BOACMD_BOAADV(void* _slink, T_integer A)
{
    // prologue/frame definition
    Frame_READER_BOACMD_BOAADV _F = { (Frame_READER_BOACMD*)_slink, A };

    // subroutine body
    // line 2949
    if(((_F._slink->INTS + _F.A) < C_ZS))
    {
        // line 2950
        _F._slink->INTS = (_F._slink->INTS + _F.A);
    }
    else
    {
        // line 2952
        _F._slink->INTS = C_ZS;
    }

    { /* NOP */ }
}

// line 2956
//================================================================================
// scope: READER_BOACMD_BOASTO (level : 4)

// activation record
struct Frame_READER_BOACMD_BOASTO
{
   Frame_READER_BOACMD* _slink;

    // parameters
    T_TP A;
};

// function body
void P_READER_BOACMD_BOASTO(void* _slink, T_TP A)
{
    // prologue/frame definition
    Frame_READER_BOACMD_BOASTO _F = { (Frame_READER_BOACMD*)_slink, A };

    // subroutine body
    // line 2959
    BOARD.RBIS[_F._slink->INTS] = _F.A;

    // line 2960
    if((_F._slink->INTS < C_ZS))
    {
        // line 2960
        _F._slink->INTS = (_F._slink->INTS + 1);
    }

    { /* NOP */ }
}

// line 2996
//================================================================================
// scope: READER_ENDCMD (level : 3)

// activation record
struct Frame_READER_ENDCMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_ENDCMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_ENDCMD _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 2999
    throw NL_9;

    { /* NOP */ }
}

// line 3003
//================================================================================
// scope: READER_GONCMD (level : 3)

// activation record
struct Frame_READER_GONCMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_GONCMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_GONCMD _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 3006
    GOING = F_READER_RDRNUM(_F._slink);

    // line 3007
    if((GOING <= 0))
    {
        // line 3007
        GOING = 1;
    }

    // line 3009
    Jumpin = C_true;

    // line 3011
    throw NL_2;

    { /* NOP */ }
}

// line 3015
//================================================================================
// scope: READER_INICMD (level : 3)

// activation record
struct Frame_READER_INICMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_INICMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_INICMD _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 3018
    throw NL_1;

    { /* NOP */ }
}

// line 3022
//================================================================================
// scope: READER_LETCMD (level : 3)

// forward declarations
void P_READER_LETCMD_LETONE(void* _slink, T_RA A, T_integer& B);

// non-local goto targets
const int NL_READER_LETCMD_21 = 7;

// activation record
struct Frame_READER_LETCMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_LETCMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_LETCMD _F = { (Frame_READER*)_slink };

    int _nonlocalTarget = 0;

    _nonlocalGoto:
    try
    {
        switch(_nonlocalTarget)
        {
        case 0: break;
        case NL_READER_LETCMD_21: goto L_21;
        default: _RTError("unexpected non-local target");
        }

        // subroutine body
        // line 3041
        if(F_READER_RDRGNT(_F._slink, _F._slink->INRA))
        {
            // line 3043
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FKPSHD    "), FKPSHD);

            // line 3044
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FKSANQ    "), FKSANQ);

            // line 3045
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FMAXMT    "), FMAXMT);

            // line 3046
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FNODEL    "), FNODEL);

            // line 3047
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADQR    "), FPADCR[C_F1]);

            // line 3048
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADQN    "), FPADCR[C_F2]);

            // line 3049
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADQB    "), FPADCR[C_F3]);

            // line 3050
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADQF    "), FPADCR[C_F4]);

            // line 3051
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADKF    "), FPADCR[C_F5]);

            // line 3052
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADKB    "), FPADCR[C_F6]);

            // line 3053
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADKN    "), FPADCR[C_F7]);

            // line 3054
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPADWR    "), FPADCR[C_F8]);

            // line 3055
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPBLOK    "), FPBLOK);

            // line 3056
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPCONN    "), FPCONN);

            // line 3057
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FPFLNX    "), FPFLNX);

            // line 3058
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FRDUBL    "), FRDUBL);

            // line 3059
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FRK7TH    "), FRK7TH);

            // line 3060
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FTRADE    "), FTRADE);

            // line 3061
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FTRDSL    "), FTRDSL);

            // line 3062
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FTRPDK    "), FTRPDK);

            // line 3063
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FTRPWN    "), FTRPWN);

            // line 3064
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FWKING    "), FWKING);

            // line 3065
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FWMAJM    "), FWMAJM);

            // line 3066
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FWMINM    "), FWMINM);

            // line 3067
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FWPAWN    "), FWPAWN);

            // line 3068
            P_READER_LETCMD_LETONE(&_F, T_RA::C("FWROOK    "), FWROOK);

            // line 3069
            P_READER_LETCMD_LETONE(&_F, T_RA::C("WINDOW    "), WINDOW);

            // line 3070
            P_READER_RDRERR(_F._slink, T_RN::C("ILLEGAL LET VARIABLE NAME     "));

            { /* NOP */ }
        }

        L_21:
        { /* NOP */ }
    }
    catch(int _target)
    {
        switch(_target)
        {
        case NL_READER_LETCMD_21:
            _nonlocalTarget = _target;
            goto _nonlocalGoto;
        default: throw;
        }
    }
}

// line 3027
//================================================================================
// scope: READER_LETCMD_LETONE (level : 4)

// activation record
struct Frame_READER_LETCMD_LETONE
{
   Frame_READER_LETCMD* _slink;

    // parameters
    T_RA A;
    T_integer& B;
};

// function body
void P_READER_LETCMD_LETONE(void* _slink, T_RA A, T_integer& B)
{
    // prologue/frame definition
    Frame_READER_LETCMD_LETONE _F = { (Frame_READER_LETCMD*)_slink, A, B };

    // subroutine body
    // line 3032
    if(_strcmpEQ<10>(_F.A, _F._slink->_slink->INRA))
    {
        // line 3034
        _F.B = F_READER_RDRNUM(_F._slink->_slink);

        // line 3035
        throw NL_READER_LETCMD_21;

        { /* NOP */ }
    }

    { /* NOP */ }
}

// line 3076
//================================================================================
// scope: READER_PLECMD (level : 3)

// forward declarations
void P_READER_PLECMD_PRIONE(void* _slink, T_RA A, T_integer B);

// non-local goto targets
const int NL_READER_PLECMD_21 = 8;

// activation record
struct Frame_READER_PLECMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_PLECMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_PLECMD _F = { (Frame_READER*)_slink };

    int _nonlocalTarget = 0;

    _nonlocalGoto:
    try
    {
        switch(_nonlocalTarget)
        {
        case 0: break;
        case NL_READER_PLECMD_21: goto L_21;
        default: _RTError("unexpected non-local target");
        }

        // subroutine body
        // line 3096
        L_21:
        while(F_READER_RDRGNT(_F._slink, _F._slink->INRA))
        {
            // line 3098
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FKPSHD    "), FKPSHD);

            // line 3099
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FKSANQ    "), FKSANQ);

            // line 3100
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FMAXMT    "), FMAXMT);

            // line 3101
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FNODEL    "), FNODEL);

            // line 3102
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADQR    "), FPADCR[C_F1]);

            // line 3103
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADQN    "), FPADCR[C_F2]);

            // line 3104
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADQB    "), FPADCR[C_F3]);

            // line 3105
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADQF    "), FPADCR[C_F4]);

            // line 3106
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADKF    "), FPADCR[C_F5]);

            // line 3107
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADKB    "), FPADCR[C_F6]);

            // line 3108
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADKN    "), FPADCR[C_F7]);

            // line 3109
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPADKR    "), FPADCR[C_F8]);

            // line 3110
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPBLOK    "), FPBLOK);

            // line 3111
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPCONN    "), FPCONN);

            // line 3112
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FPFLNX    "), FPFLNX);

            // line 3113
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FRDUBL    "), FRDUBL);

            // line 3114
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FRK7TH    "), FRK7TH);

            // line 3115
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FTRADE    "), FTRADE);

            // line 3116
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FTRDSL    "), FTRDSL);

            // line 3117
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FTRPDK    "), FTRPDK);

            // line 3118
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FTRPWN    "), FTRPWN);

            // line 3119
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FWKING    "), FWKING);

            // line 3120
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FWMAJM    "), FWMAJM);

            // line 3121
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FWMINM    "), FWMINM);

            // line 3122
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FWPAWN    "), FWPAWN);

            // line 3123
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("FWROOK    "), FWROOK);

            // line 3124
            P_READER_PLECMD_PRIONE(&_F, T_RA::C("WINDOW    "), WINDOW);

            // line 3125
            P_READER_RDRERR(_F._slink, T_RN::C(" ILLEGAL  VARIABLE NAME       "));

            { /* NOP */ }
        }

        { /* NOP */ }
    }
    catch(int _target)
    {
        switch(_target)
        {
        case NL_READER_PLECMD_21:
            _nonlocalTarget = _target;
            goto _nonlocalGoto;
        default: throw;
        }
    }
}

// line 3081
//================================================================================
// scope: READER_PLECMD_PRIONE (level : 4)

// activation record
struct Frame_READER_PLECMD_PRIONE
{
   Frame_READER_PLECMD* _slink;

    // parameters
    T_RA A;
    T_integer B;
};

// function body
void P_READER_PLECMD_PRIONE(void* _slink, T_RA A, T_integer B)
{
    // prologue/frame definition
    Frame_READER_PLECMD_PRIONE _F = { (Frame_READER_PLECMD*)_slink, A, B };

    // subroutine body
    // line 3086
    if(_strcmpEQ<10>(_F._slink->_slink->INRA, _F.A))
    {
        // line 3088
        Output << _F.A << _F.B << _WRITELN;

        // line 3089
        throw NL_READER_PLECMD_21;

        { /* NOP */ }
    }

    { /* NOP */ }
}

// line 3131
//================================================================================
// scope: READER_PRICMD (level : 3)

// activation record
struct Frame_READER_PRICMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_PRICMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_PRICMD _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 3134
    if(F_READER_RDRGNT(_F._slink, _F._slink->INRA))
    {
        // line 3135
        P_PRINTB(nullptr, MBORD);
    }
    else
    {
        // line 3137
        P_PRINTB(nullptr, BOARD.RBIS);
    }

    { /* NOP */ }
}

// line 3141
//================================================================================
// scope: READER_PAMCMD (level : 3)

// activation record
struct Frame_READER_PAMCMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_PAMCMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_PAMCMD _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 3144
    while(F_READER_RDRGNT(_F._slink, _F._slink->INRA))
    {
        // line 3145
        if((_F._slink->INRA[C_AA] == 'T'))
        {
            // line 3146
            P_PRINAM(nullptr, ATKTO);
        }
        else
        {
            // line 3148
            if((_F._slink->INRA[C_AA] == 'F'))
            {
                // line 3149
                P_PRINAM(nullptr, ATKFR);
            }
            else
            {
                // line 3151
                P_READER_RDRERR(_F._slink, T_RN::C(" ATTACK MAP NOT TO OR FROM    "));
            }
        }
    }

    { /* NOP */ }
}

// line 3155
//================================================================================
// scope: READER_POPCMD (level : 3)

// activation record
struct Frame_READER_POPCMD
{
   Frame_READER* _slink;

    // locals
    T_TQ INTQ;
};

// function body
void P_READER_POPCMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_POPCMD _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 3163
    Output << XTMA[BOARD.RBTM] << " TO MOVE." << _WRITELN;

    // line 3164
    Output << BOARD.RBTS << " ENPASSANT." << _WRITELN;

    // line 3165
    Output << "MOVE NUMBER " << BOARD.RBTI << _WRITELN;

    // line 3166
    _FOR_TO(_F.INTQ, C_LS, C_DL)
    {
        // line 3167
        if((BOARD.RBSQ & _F.INTQ))
        {
            // line 3168
            Output << XTQA[_F.INTQ] << " SIDE CASTLE LEGAL." << _WRITELN;
        }
    }
    _FOR_END(_F.INTQ)

    { /* NOP */ }

    { /* NOP */ }
}

// line 3173
//================================================================================
// scope: READER_PMVCMD (level : 3)

// activation record
struct Frame_READER_PMVCMD
{
   Frame_READER* _slink;

    // locals
    T_TW INTW;
};

// function body
void P_READER_PMVCMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_PMVCMD _F = { (Frame_READER*)_slink };

    // subroutine body
    // line 3179
    P_LSTMOV(nullptr);

    // line 3180
    _FOR_TO(_F.INTW, C_AW, (JNTW - 1))
    {
        // line 3182
        Output << _format(_F.INTW, 4, 0) << "   ";

        // line 3183
        P_PRIMOV(nullptr, MOVES[_F.INTW]);

        // line 3184
        if((((double)_F.INTW / C_LPP) == (_F.INTW / C_LPP)))
        {
            // line 3185
            P_PAUSER(nullptr);
        }

        { /* NOP */ }
    }
    _FOR_END(_F.INTW)

    { /* NOP */ }
}

// line 3190
//================================================================================
// scope: READER_SWICMD (level : 3)

// forward declarations
void P_READER_SWICMD_SWIONE(void* _slink, T_RA A, T_boolean& B);

// non-local goto targets
const int NL_READER_SWICMD_21 = 9;

// activation record
struct Frame_READER_SWICMD
{
   Frame_READER* _slink;
};

// function body
void P_READER_SWICMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_SWICMD _F = { (Frame_READER*)_slink };

    int _nonlocalTarget = 0;

    _nonlocalGoto:
    try
    {
        switch(_nonlocalTarget)
        {
        case 0: break;
        case NL_READER_SWICMD_21: goto L_21;
        default: _RTError("unexpected non-local target");
        }

        // subroutine body
        // line 3228
        L_21:
        while(F_READER_RDRGNT(_F._slink, _F._slink->INRA))
        {
            // line 3230
            P_READER_SWICMD_SWIONE(&_F, T_RA::C("EC        "), SWEC);

            // line 3231
            P_READER_SWICMD_SWIONE(&_F, T_RA::C("PA        "), SWPA);

            // line 3232
            P_READER_SWICMD_SWIONE(&_F, T_RA::C("PS        "), SWPS);

            // line 3233
            P_READER_SWICMD_SWIONE(&_F, T_RA::C("RE        "), SWRE);

            // line 3234
            P_READER_SWICMD_SWIONE(&_F, T_RA::C("SU        "), SWSU);

            // line 3235
            P_READER_SWICMD_SWIONE(&_F, T_RA::C("TR        "), SWTR);

            // line 3236
            P_READER_RDRERR(_F._slink, T_RN::C(" INVALID SWITCH OPTION        "));

            { /* NOP */ }
        }

        { /* NOP */ }
    }
    catch(int _target)
    {
        switch(_target)
        {
        case NL_READER_SWICMD_21:
            _nonlocalTarget = _target;
            goto _nonlocalGoto;
        default: throw;
        }
    }
}

// line 3195
//================================================================================
// scope: READER_SWICMD_SWIONE (level : 4)

// activation record
struct Frame_READER_SWICMD_SWIONE
{
   Frame_READER_SWICMD* _slink;

    // parameters
    T_RA A;
    T_boolean& B;

    // locals
    T_TJ IMTJ;
};

// function body
void P_READER_SWICMD_SWIONE(void* _slink, T_RA A, T_boolean& B)
{
    // prologue/frame definition
    Frame_READER_SWICMD_SWIONE _F = { (Frame_READER_SWICMD*)_slink, A, B };

    // subroutine body
    // line 3203
    if(_strcmpEQ<10>(_F._slink->_slink->INRA, _F.A))
    {
        // line 3205
        _F.IMTJ = JNTJ;

        // line 3206
        if(F_READER_RDRGNT(_F._slink->_slink, _F._slink->_slink->INRA))
        {
            // line 3208
            if(_strcmpEQ<10>(_F._slink->_slink->INRA, "ON        "))
            {
                // line 3209
                _F.B = C_true;
            }
            else
            {
                // line 3211
                if(_strcmpEQ<10>(_F._slink->_slink->INRA, "OFF       "))
                {
                    // line 3212
                    _F.B = C_false;
                }
                else
                {
                    // line 3214
                    JNTJ = _F.IMTJ;
                }
            }

            // line 3215
            P_PRISWI(nullptr, _F.A, _F.B);

            { /* NOP */ }
        }
        else
        {
            // line 3219
            P_PRISWI(nullptr, _F.A, _F.B);

            { /* NOP */ }
        }

        // line 3221
        throw NL_READER_SWICMD_21;

        { /* NOP */ }
    }

    { /* NOP */ }
}

// line 3241
//================================================================================
// scope: READER_STACMD (level : 3)

// types
typedef _T_Pfn<void (*)(void*)> T_READER_STACMD_subroutine_47;

// forward declarations
void P_READER_STACMD_STAEPF(void* _slink, T_RA A, T_TF B);
void P_READER_STACMD_STACAK(void* _slink);
void P_READER_STACMD_STACAQ(void* _slink);
void P_READER_STACMD_STADRK(void* _slink);
void P_READER_STACMD_STAENP(void* _slink);
void P_READER_STACMD_STAGOS(void* _slink);
void P_READER_STACMD_STALIT(void* _slink);
void P_READER_STACMD_STANUM(void* _slink);
void P_READER_STACMD_STAOPT(void* _slink, T_RA A, T_READER_STACMD_subroutine_47 STAXXX);

// non-local goto targets
const int NL_READER_STACMD_21 = 10;

// activation record
struct Frame_READER_STACMD
{
   Frame_READER* _slink;

    // locals
    T_RA INRA;
    T_TM INTM;
};

// function body
void P_READER_STACMD(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD _F = { (Frame_READER*)_slink };

    int _nonlocalTarget = 0;

    _nonlocalGoto:
    try
    {
        switch(_nonlocalTarget)
        {
        case 0: break;
        case NL_READER_STACMD_21: goto L_21;
        default: _RTError("unexpected non-local target");
        }

        // subroutine body
        // line 3350
        P_CLSTAT(nullptr);

        // line 3351
        _F.INTM = C_LITE;

        // line 3353
        L_21:
        while(F_READER_RDRGNT(_F._slink, _F.INRA))
        {
            // line 3355
            P_READER_STACMD_STAOPT(&_F, T_RA::C("D         "), _makePfn(P_READER_STACMD_STADRK, &_F));

            // line 3356
            P_READER_STACMD_STAOPT(&_F, T_RA::C("EP        "), _makePfn(P_READER_STACMD_STAENP, &_F));

            // line 3357
            P_READER_STACMD_STAOPT(&_F, T_RA::C("G         "), _makePfn(P_READER_STACMD_STAGOS, &_F));

            // line 3358
            P_READER_STACMD_STAOPT(&_F, T_RA::C("L         "), _makePfn(P_READER_STACMD_STALIT, &_F));

            // line 3359
            P_READER_STACMD_STAOPT(&_F, T_RA::C("N         "), _makePfn(P_READER_STACMD_STANUM, &_F));

            // line 3360
            P_READER_STACMD_STAOPT(&_F, T_RA::C("OO        "), _makePfn(P_READER_STACMD_STACAK, &_F));

            // line 3361
            P_READER_STACMD_STAOPT(&_F, T_RA::C("OOO       "), _makePfn(P_READER_STACMD_STACAQ, &_F));

            // line 3362
            P_CLSTAT(nullptr);

            // line 3363
            P_READER_RDRERR(_F._slink, T_RN::C(" INVALID STATUS OPTION        "));

            { /* NOP */ }
        }

        { /* NOP */ }
    }
    catch(int _target)
    {
        switch(_target)
        {
        case NL_READER_STACMD_21:
            _nonlocalTarget = _target;
            goto _nonlocalGoto;
        default: throw;
        }
    }
}

// line 3250
//================================================================================
// scope: READER_STACMD_STAEPF (level : 4)

// activation record
struct Frame_READER_STACMD_STAEPF
{
   Frame_READER_STACMD* _slink;

    // parameters
    T_RA A;
    T_TF B;
};

// function body
void P_READER_STACMD_STAEPF(void* _slink, T_RA A, T_TF B)
{
    // prologue/frame definition
    Frame_READER_STACMD_STAEPF _F = { (Frame_READER_STACMD*)_slink, A, B };

    // subroutine body
    // line 3255
    if(_strcmpEQ<10>(_F.A, _F._slink->INRA))
    {
        // line 3257
        if((_F._slink->INTM == C_LITE))
        {
            // line 3258
            BOARD.RBTS = XTRFS[C_R6][_F.B];
        }
        else
        {
            // line 3260
            BOARD.RBTS = XTRFS[C_R3][_F.B];
        }

        // line 3261
        throw NL_READER_STACMD_21;

        { /* NOP */ }
    }

    { /* NOP */ }
}

// line 3266
//================================================================================
// scope: READER_STACMD_STACAK (level : 4)

// activation record
struct Frame_READER_STACMD_STACAK
{
   Frame_READER_STACMD* _slink;
};

// function body
void P_READER_STACMD_STACAK(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD_STACAK _F = { (Frame_READER_STACMD*)_slink };

    // hoisted definitions
    _T_GenericSet _setLiteral1;
    _setLiteral1.set(C_LS);

    _T_GenericSet _setLiteral2;
    _setLiteral2.set(C_DS);

    // subroutine body
    // line 3269
    if((_F._slink->INTM == C_LITE))
    {
        // line 3270
        BOARD.RBSQ = (BOARD.RBSQ + _setLiteral1);
    }
    else
    {
        // line 3272
        BOARD.RBSQ = (BOARD.RBSQ + _setLiteral2);
    }

    { /* NOP */ }
}

// line 3276
//================================================================================
// scope: READER_STACMD_STACAQ (level : 4)

// activation record
struct Frame_READER_STACMD_STACAQ
{
   Frame_READER_STACMD* _slink;
};

// function body
void P_READER_STACMD_STACAQ(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD_STACAQ _F = { (Frame_READER_STACMD*)_slink };

    // hoisted definitions
    _T_GenericSet _setLiteral1;
    _setLiteral1.set(C_LL);

    _T_GenericSet _setLiteral2;
    _setLiteral2.set(C_DL);

    // subroutine body
    // line 3279
    if((_F._slink->INTM == C_LITE))
    {
        // line 3280
        BOARD.RBSQ = (BOARD.RBSQ + _setLiteral1);
    }
    else
    {
        // line 3282
        BOARD.RBSQ = (BOARD.RBSQ + _setLiteral2);
    }

    { /* NOP */ }
}

// line 3286
//================================================================================
// scope: READER_STACMD_STADRK (level : 4)

// activation record
struct Frame_READER_STACMD_STADRK
{
   Frame_READER_STACMD* _slink;
};

// function body
void P_READER_STACMD_STADRK(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD_STADRK _F = { (Frame_READER_STACMD*)_slink };

    // subroutine body
    // line 3289
    _F._slink->INTM = C_DARK;

    { /* NOP */ }
}

// line 3293
//================================================================================
// scope: READER_STACMD_STAENP (level : 4)

// activation record
struct Frame_READER_STACMD_STAENP
{
   Frame_READER_STACMD* _slink;
};

// function body
void P_READER_STACMD_STAENP(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD_STAENP _F = { (Frame_READER_STACMD*)_slink };

    // subroutine body
    // line 3296
    if((!F_READER_RDRGNT(_F._slink->_slink, _F._slink->INRA)))
    {
        // line 3298
        P_CLSTAT(nullptr);

        // line 3299
        P_READER_RDRERR(_F._slink->_slink, T_RN::C(" ENPASSANT FILE OMITTED       "));

        { /* NOP */ }
    }

    // line 3301
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("QR        "), C_F1);

    // line 3302
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("QN        "), C_F2);

    // line 3303
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("QB        "), C_F3);

    // line 3304
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("Q         "), C_F4);

    // line 3305
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("K         "), C_F5);

    // line 3306
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("KB        "), C_F6);

    // line 3307
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("KN        "), C_F7);

    // line 3308
    P_READER_STACMD_STAEPF(_F._slink, T_RA::C("KR        "), C_F8);

    // line 3309
    P_CLSTAT(nullptr);

    // line 3310
    P_READER_RDRERR(_F._slink->_slink, T_RN::C(" ILLEGAL ENPASSANT FILE       "));

    { /* NOP */ }
}

// line 3314
//================================================================================
// scope: READER_STACMD_STAGOS (level : 4)

// activation record
struct Frame_READER_STACMD_STAGOS
{
   Frame_READER_STACMD* _slink;
};

// function body
void P_READER_STACMD_STAGOS(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD_STAGOS _F = { (Frame_READER_STACMD*)_slink };

    // subroutine body
    // line 3317
    BOARD.RBTM = _F._slink->INTM;

    // line 3318
    JNTM = _F._slink->INTM;

    { /* NOP */ }
}

// line 3322
//================================================================================
// scope: READER_STACMD_STALIT (level : 4)

// activation record
struct Frame_READER_STACMD_STALIT
{
   Frame_READER_STACMD* _slink;
};

// function body
void P_READER_STACMD_STALIT(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD_STALIT _F = { (Frame_READER_STACMD*)_slink };

    // subroutine body
    // line 3325
    _F._slink->INTM = C_LITE;

    { /* NOP */ }
}

// line 3329
//================================================================================
// scope: READER_STACMD_STANUM (level : 4)

// activation record
struct Frame_READER_STACMD_STANUM
{
   Frame_READER_STACMD* _slink;
};

// function body
void P_READER_STACMD_STANUM(void* _slink)
{
    // prologue/frame definition
    Frame_READER_STACMD_STANUM _F = { (Frame_READER_STACMD*)_slink };

    // subroutine body
    // line 3332
    BOARD.RBTI = F_READER_RDRNUM(_F._slink->_slink);

    { /* NOP */ }
}

// line 3336
//================================================================================
// scope: READER_STACMD_STAOPT (level : 4)

// activation record
struct Frame_READER_STACMD_STAOPT
{
   Frame_READER_STACMD* _slink;

    // parameters
    T_RA A;
    T_READER_STACMD_subroutine_47 STAXXX;
};

// function body
void P_READER_STACMD_STAOPT(void* _slink, T_RA A, T_READER_STACMD_subroutine_47 STAXXX)
{
    // prologue/frame definition
    Frame_READER_STACMD_STAOPT _F = { (Frame_READER_STACMD*)_slink, A, STAXXX };

    // subroutine body
    // line 3341
    if(_strcmpEQ<10>(_F._slink->INRA, _F.A))
    {
        // line 3343

license_type: permissive

branch_name: refs/heads/master

extension: cpp