main 7c28905ddbca cached
132 files
3.5 MB
931.3k tokens
3265 symbols
1 requests
Download .txt
Showing preview only (3,724K chars total). Download the full file or copy to clipboard to get everything.
Repository: sksalahuddin2828/C_Programming
Branch: main
Commit: 7c28905ddbca
Files: 132
Total size: 3.5 MB

Directory structure:
gitextract_msw6v1wo/

├── Asdl.c
├── Asm_Trampoline.S
├── Assemble.c
├── Ast.c
├── Ast_Opt.c
├── Ast_Unparse.c
├── BltinModule.c
├── Bootstrap_Hash.c
├── ByteCodes.c
├── CeVal.c
├── Ceval_Gil.c
├── Ceval_Macros.h
├── Clinic/
│   ├── Python-tokenize.c.h
│   ├── _warnings.c.h
│   ├── bltinmodule.c.h
│   ├── context.c.h
│   ├── import.c.h
│   ├── instrumentation.c.h
│   ├── marshal.c.h
│   ├── sysmodule.c.h
│   └── traceback.c.h
├── CodeCS.c
├── Compile.c
├── Condvar.h
├── Context.c
├── Dtoa.c
├── Dup2.c
├── Dynamic_Annotations.c
├── Dynload_Hpux.c
├── Dynload_Shlib.c
├── Dynload_Stub.c
├── Dynload_Win.c
├── Emscripten_Signal.c
├── Errors.c
├── Fileutils.c
├── Flowgraph.c
├── Formatter_Unicode.c
├── Frame.c
├── Frozen.c
├── FrozenMain.c
├── Future.c
├── Game/
│   ├── CMakeLists.txt
│   ├── graphics.asm
│   ├── linked_list.asm
│   ├── main.asm
│   ├── memory.asm
│   └── utils.asm
├── Game I/
│   ├── CMakeLists.txt
│   ├── c_key_event.h
│   ├── c_list.c
│   ├── c_list.h
│   ├── c_rectangle.c
│   ├── c_rectangle.h
│   ├── c_result.h
│   ├── c_vector2.c
│   ├── c_vector2.h
│   ├── c_window.c
│   ├── c_window.h
│   └── main.c
├── Game II/
│   ├── CMakeLists.txt
│   ├── colour.cpp
│   ├── colour.h
│   ├── entity.cpp
│   ├── entity.h
│   ├── key_event.h
│   ├── main.cpp
│   ├── rectangle.cpp
│   ├── rectangle.h
│   ├── vector2.cpp
│   ├── vector2.h
│   ├── window.cpp
│   └── window.h
├── GeTargs.c
├── Generated_Cases.c.h
├── GetArgs.c
├── GetCompiler.c
├── GetCopyRight.c
├── GetCopyright.c
├── GetOpt.c
├── GetPlatForm.c
├── GetVersion.c
├── Get_Compiler.c
├── Get_Opt.c
├── Get_Plat_Form.c
├── Getversion.c
├── Hamt.c
├── HashTable.c
├── ImPort.c
├── ImPortdl.c
├── ImPortdl.h
├── InTrinSics.c
├── InitConfig.c
├── InstruMenTation.c
├── InstruMentation.c
├── Legacy_Tracing.c
├── MakeOpCodeTargets.py
├── MarShal.c
├── ModSupport.c
├── MySnPrintf.c
├── MyStrtoul.c
├── OpCode_MetaData.h
├── OpCode_Targets.h
├── OptiMizer.c
├── PathConfig.c
├── Perf_Trampoline.c
├── PreConfig.c
├── PyArena.c
├── PyCtype.c
├── PyFpc.c
├── PyHash.c
├── PyLifeCycle.c
├── PyMath.c
├── PyState.c
├── PyStrcmp.c
├── PyStrhex.c
├── PyStrtod.c
├── PyTime.c
├── Python-AST.c
├── Python-Tokenize.c
├── PythonRun.c
├── Specialize.c
├── Stdlib_Module_Names.h
├── StrucMember.c
├── Suggestions.c
├── SyMTable.c
├── SySModule.c
├── Thread.c
├── Thread_NT.h
├── Thread_Pthread.h
├── Thread_Pthread_Dtubs.h
├── TraceBack.c
└── TraceMalloc.c

================================================
FILE CONTENTS
================================================

================================================
FILE: Asdl.c
================================================
#include "Python.h"
#include "pycore_asdl.h"

GENERATE_ASDL_SEQ_CONSTRUCTOR(generic, void*);
GENERATE_ASDL_SEQ_CONSTRUCTOR(identifier, PyObject*);
GENERATE_ASDL_SEQ_CONSTRUCTOR(int, int);


================================================
FILE: Asm_Trampoline.S
================================================
    .text
    .globl	_Py_trampoline_func_start
# The following assembly is equivalent to:
# PyObject *
# trampoline(PyThreadState *ts, _PyInterpreterFrame *f,
#            int throwflag, py_evaluator evaluator)
# {
#     return evaluator(ts, f, throwflag);
# }
_Py_trampoline_func_start:
#ifdef __x86_64__
    sub    $8, %rsp
    call    *%rcx
    add    $8, %rsp
    ret
#endif // __x86_64__
#if defined(__aarch64__) && defined(__AARCH64EL__) && !defined(__ILP32__)
    // ARM64 little endian, 64bit ABI
    // generate with aarch64-linux-gnu-gcc 12.1
    stp     x29, x30, [sp, -16]!
    mov     x29, sp
    blr     x3
    ldp     x29, x30, [sp], 16
    ret
#endif
    .globl	_Py_trampoline_func_end
_Py_trampoline_func_end:
    .section        .note.GNU-stack,"",@progbits


================================================
FILE: Assemble.c
================================================
#include <stdbool.h>

#include "Python.h"
#include "pycore_code.h"          // write_location_entry_start()
#include "pycore_compile.h"
#include "pycore_opcode.h"        // _PyOpcode_Caches[] and opcode category macros


#define DEFAULT_CODE_SIZE 128
#define DEFAULT_LNOTAB_SIZE 16
#define DEFAULT_CNOTAB_SIZE 32

#undef SUCCESS
#undef ERROR
#define SUCCESS 0
#define ERROR -1

#define RETURN_IF_ERROR(X)  \
    if ((X) == -1) {        \
        return ERROR;       \
    }

typedef _PyCompilerSrcLocation location;
typedef _PyCompile_Instruction instruction;
typedef _PyCompile_InstructionSequence instr_sequence;

static inline bool
same_location(location a, location b)
{
    return a.lineno == b.lineno &&
           a.end_lineno == b.end_lineno &&
           a.col_offset == b.col_offset &&
           a.end_col_offset == b.end_col_offset;
}

struct assembler {
    PyObject *a_bytecode;  /* bytes containing bytecode */
    int a_offset;              /* offset into bytecode */
    PyObject *a_except_table;  /* bytes containing exception table */
    int a_except_table_off;    /* offset into exception table */
    /* Location Info */
    int a_lineno;          /* lineno of last emitted instruction */
    PyObject* a_linetable; /* bytes containing location info */
    int a_location_off;    /* offset of last written location info frame */
};

static int
assemble_init(struct assembler *a, int firstlineno)
{
    memset(a, 0, sizeof(struct assembler));
    a->a_lineno = firstlineno;
    a->a_linetable = NULL;
    a->a_location_off = 0;
    a->a_except_table = NULL;
    a->a_bytecode = PyBytes_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
    if (a->a_bytecode == NULL) {
        goto error;
    }
    a->a_linetable = PyBytes_FromStringAndSize(NULL, DEFAULT_CNOTAB_SIZE);
    if (a->a_linetable == NULL) {
        goto error;
    }
    a->a_except_table = PyBytes_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
    if (a->a_except_table == NULL) {
        goto error;
    }
    return SUCCESS;
error:
    Py_XDECREF(a->a_bytecode);
    Py_XDECREF(a->a_linetable);
    Py_XDECREF(a->a_except_table);
    return ERROR;
}

static void
assemble_free(struct assembler *a)
{
    Py_XDECREF(a->a_bytecode);
    Py_XDECREF(a->a_linetable);
    Py_XDECREF(a->a_except_table);
}

static inline void
write_except_byte(struct assembler *a, int byte) {
    unsigned char *p = (unsigned char *) PyBytes_AS_STRING(a->a_except_table);
    p[a->a_except_table_off++] = byte;
}

#define CONTINUATION_BIT 64

static void
assemble_emit_exception_table_item(struct assembler *a, int value, int msb)
{
    assert ((msb | 128) == 128);
    assert(value >= 0 && value < (1 << 30));
    if (value >= 1 << 24) {
        write_except_byte(a, (value >> 24) | CONTINUATION_BIT | msb);
        msb = 0;
    }
    if (value >= 1 << 18) {
        write_except_byte(a, ((value >> 18)&0x3f) | CONTINUATION_BIT | msb);
        msb = 0;
    }
    if (value >= 1 << 12) {
        write_except_byte(a, ((value >> 12)&0x3f) | CONTINUATION_BIT | msb);
        msb = 0;
    }
    if (value >= 1 << 6) {
        write_except_byte(a, ((value >> 6)&0x3f) | CONTINUATION_BIT | msb);
        msb = 0;
    }
    write_except_byte(a, (value&0x3f) | msb);
}

/* See Objects/exception_handling_notes.txt for details of layout */
#define MAX_SIZE_OF_ENTRY 20

static int
assemble_emit_exception_table_entry(struct assembler *a, int start, int end,
                                    _PyCompile_ExceptHandlerInfo *handler)
{
    Py_ssize_t len = PyBytes_GET_SIZE(a->a_except_table);
    if (a->a_except_table_off + MAX_SIZE_OF_ENTRY >= len) {
        RETURN_IF_ERROR(_PyBytes_Resize(&a->a_except_table, len * 2));
    }
    int size = end-start;
    assert(end > start);
    int target = handler->h_offset;
    int depth = handler->h_startdepth - 1;
    if (handler->h_preserve_lasti > 0) {
        depth -= 1;
    }
    assert(depth >= 0);
    int depth_lasti = (depth<<1) | handler->h_preserve_lasti;
    assemble_emit_exception_table_item(a, start, (1<<7));
    assemble_emit_exception_table_item(a, size, 0);
    assemble_emit_exception_table_item(a, target, 0);
    assemble_emit_exception_table_item(a, depth_lasti, 0);
    return SUCCESS;
}

static int
assemble_exception_table(struct assembler *a, instr_sequence *instrs)
{
    int ioffset = 0;
    _PyCompile_ExceptHandlerInfo handler;
    handler.h_offset = -1;
    handler.h_startdepth = -1;
    handler.h_preserve_lasti = -1;
    int start = -1;
    for (int i = 0; i < instrs->s_used; i++) {
        instruction *instr = &instrs->s_instrs[i];
        if (instr->i_except_handler_info.h_offset != handler.h_offset) {
            if (handler.h_offset >= 0) {
                RETURN_IF_ERROR(
                    assemble_emit_exception_table_entry(a, start, ioffset, &handler));
            }
            start = ioffset;
            handler = instr->i_except_handler_info;
        }
        ioffset += _PyCompile_InstrSize(instr->i_opcode, instr->i_oparg);
    }
    if (handler.h_offset >= 0) {
        RETURN_IF_ERROR(assemble_emit_exception_table_entry(a, start, ioffset, &handler));
    }
    return SUCCESS;
}


/* Code location emitting code. See locations.md for a description of the format. */

#define MSB 0x80

static void
write_location_byte(struct assembler* a, int val)
{
    PyBytes_AS_STRING(a->a_linetable)[a->a_location_off] = val&255;
    a->a_location_off++;
}


static uint8_t *
location_pointer(struct assembler* a)
{
    return (uint8_t *)PyBytes_AS_STRING(a->a_linetable) +
        a->a_location_off;
}

static void
write_location_first_byte(struct assembler* a, int code, int length)
{
    a->a_location_off += write_location_entry_start(
        location_pointer(a), code, length);
}

static void
write_location_varint(struct assembler* a, unsigned int val)
{
    uint8_t *ptr = location_pointer(a);
    a->a_location_off += write_varint(ptr, val);
}


static void
write_location_signed_varint(struct assembler* a, int val)
{
    uint8_t *ptr = location_pointer(a);
    a->a_location_off += write_signed_varint(ptr, val);
}

static void
write_location_info_short_form(struct assembler* a, int length, int column, int end_column)
{
    assert(length > 0 &&  length <= 8);
    int column_low_bits = column & 7;
    int column_group = column >> 3;
    assert(column < 80);
    assert(end_column >= column);
    assert(end_column - column < 16);
    write_location_first_byte(a, PY_CODE_LOCATION_INFO_SHORT0 + column_group, length);
    write_location_byte(a, (column_low_bits << 4) | (end_column - column));
}

static void
write_location_info_oneline_form(struct assembler* a, int length, int line_delta, int column, int end_column)
{
    assert(length > 0 &&  length <= 8);
    assert(line_delta >= 0 && line_delta < 3);
    assert(column < 128);
    assert(end_column < 128);
    write_location_first_byte(a, PY_CODE_LOCATION_INFO_ONE_LINE0 + line_delta, length);
    write_location_byte(a, column);
    write_location_byte(a, end_column);
}

static void
write_location_info_long_form(struct assembler* a, location loc, int length)
{
    assert(length > 0 &&  length <= 8);
    write_location_first_byte(a, PY_CODE_LOCATION_INFO_LONG, length);
    write_location_signed_varint(a, loc.lineno - a->a_lineno);
    assert(loc.end_lineno >= loc.lineno);
    write_location_varint(a, loc.end_lineno - loc.lineno);
    write_location_varint(a, loc.col_offset + 1);
    write_location_varint(a, loc.end_col_offset + 1);
}

static void
write_location_info_none(struct assembler* a, int length)
{
    write_location_first_byte(a, PY_CODE_LOCATION_INFO_NONE, length);
}

static void
write_location_info_no_column(struct assembler* a, int length, int line_delta)
{
    write_location_first_byte(a, PY_CODE_LOCATION_INFO_NO_COLUMNS, length);
    write_location_signed_varint(a, line_delta);
}

#define THEORETICAL_MAX_ENTRY_SIZE 25 /* 1 + 6 + 6 + 6 + 6 */


static int
write_location_info_entry(struct assembler* a, location loc, int isize)
{
    Py_ssize_t len = PyBytes_GET_SIZE(a->a_linetable);
    if (a->a_location_off + THEORETICAL_MAX_ENTRY_SIZE >= len) {
        assert(len > THEORETICAL_MAX_ENTRY_SIZE);
        RETURN_IF_ERROR(_PyBytes_Resize(&a->a_linetable, len*2));
    }
    if (loc.lineno < 0) {
        write_location_info_none(a, isize);
        return SUCCESS;
    }
    int line_delta = loc.lineno - a->a_lineno;
    int column = loc.col_offset;
    int end_column = loc.end_col_offset;
    assert(column >= -1);
    assert(end_column >= -1);
    if (column < 0 || end_column < 0) {
        if (loc.end_lineno == loc.lineno || loc.end_lineno == -1) {
            write_location_info_no_column(a, isize, line_delta);
            a->a_lineno = loc.lineno;
            return SUCCESS;
        }
    }
    else if (loc.end_lineno == loc.lineno) {
        if (line_delta == 0 && column < 80 && end_column - column < 16 && end_column >= column) {
            write_location_info_short_form(a, isize, column, end_column);
            return SUCCESS;
        }
        if (line_delta >= 0 && line_delta < 3 && column < 128 && end_column < 128) {
            write_location_info_oneline_form(a, isize, line_delta, column, end_column);
            a->a_lineno = loc.lineno;
            return SUCCESS;
        }
    }
    write_location_info_long_form(a, loc, isize);
    a->a_lineno = loc.lineno;
    return SUCCESS;
}

static int
assemble_emit_location(struct assembler* a, location loc, int isize)
{
    if (isize == 0) {
        return SUCCESS;
    }
    while (isize > 8) {
        RETURN_IF_ERROR(write_location_info_entry(a, loc, 8));
        isize -= 8;
    }
    return write_location_info_entry(a, loc, isize);
}

static int
assemble_location_info(struct assembler *a, instr_sequence *instrs,
                       int firstlineno)
{
    a->a_lineno = firstlineno;
    location loc = NO_LOCATION;
    int size = 0;
    for (int i = 0; i < instrs->s_used; i++) {
        instruction *instr = &instrs->s_instrs[i];
        if (!same_location(loc, instr->i_loc)) {
                RETURN_IF_ERROR(assemble_emit_location(a, loc, size));
                loc = instr->i_loc;
                size = 0;
        }
        size += _PyCompile_InstrSize(instr->i_opcode, instr->i_oparg);
    }
    RETURN_IF_ERROR(assemble_emit_location(a, loc, size));
    return SUCCESS;
}

static void
write_instr(_Py_CODEUNIT *codestr, instruction *instr, int ilen)
{
    int opcode = instr->i_opcode;
    assert(!IS_PSEUDO_OPCODE(opcode));
    int oparg = instr->i_oparg;
    assert(HAS_ARG(opcode) || oparg == 0);
    int caches = _PyOpcode_Caches[opcode];
    switch (ilen - caches) {
        case 4:
            codestr->op.code = EXTENDED_ARG;
            codestr->op.arg = (oparg >> 24) & 0xFF;
            codestr++;
            /* fall through */
        case 3:
            codestr->op.code = EXTENDED_ARG;
            codestr->op.arg = (oparg >> 16) & 0xFF;
            codestr++;
            /* fall through */
        case 2:
            codestr->op.code = EXTENDED_ARG;
            codestr->op.arg = (oparg >> 8) & 0xFF;
            codestr++;
            /* fall through */
        case 1:
            codestr->op.code = opcode;
            codestr->op.arg = oparg & 0xFF;
            codestr++;
            break;
        default:
            Py_UNREACHABLE();
    }
    while (caches--) {
        codestr->op.code = CACHE;
        codestr->op.arg = 0;
        codestr++;
    }
}

/* assemble_emit_instr()
   Extend the bytecode with a new instruction.
   Update lnotab if necessary.
*/

static int
assemble_emit_instr(struct assembler *a, instruction *instr)
{
    Py_ssize_t len = PyBytes_GET_SIZE(a->a_bytecode);
    _Py_CODEUNIT *code;

    int size = _PyCompile_InstrSize(instr->i_opcode, instr->i_oparg);
    if (a->a_offset + size >= len / (int)sizeof(_Py_CODEUNIT)) {
        if (len > PY_SSIZE_T_MAX / 2) {
            return ERROR;
        }
        RETURN_IF_ERROR(_PyBytes_Resize(&a->a_bytecode, len * 2));
    }
    code = (_Py_CODEUNIT *)PyBytes_AS_STRING(a->a_bytecode) + a->a_offset;
    a->a_offset += size;
    write_instr(code, instr, size);
    return SUCCESS;
}

static int
assemble_emit(struct assembler *a, instr_sequence *instrs,
              int first_lineno, PyObject *const_cache)
{
    RETURN_IF_ERROR(assemble_init(a, first_lineno));

    for (int i = 0; i < instrs->s_used; i++) {
        instruction *instr = &instrs->s_instrs[i];
        RETURN_IF_ERROR(assemble_emit_instr(a, instr));
    }

    RETURN_IF_ERROR(assemble_location_info(a, instrs, a->a_lineno));

    RETURN_IF_ERROR(assemble_exception_table(a, instrs));

    RETURN_IF_ERROR(_PyBytes_Resize(&a->a_except_table, a->a_except_table_off));
    RETURN_IF_ERROR(_PyCompile_ConstCacheMergeOne(const_cache, &a->a_except_table));

    RETURN_IF_ERROR(_PyBytes_Resize(&a->a_linetable, a->a_location_off));
    RETURN_IF_ERROR(_PyCompile_ConstCacheMergeOne(const_cache, &a->a_linetable));

    RETURN_IF_ERROR(_PyBytes_Resize(&a->a_bytecode, a->a_offset * sizeof(_Py_CODEUNIT)));
    RETURN_IF_ERROR(_PyCompile_ConstCacheMergeOne(const_cache, &a->a_bytecode));
    return SUCCESS;
}

static PyObject *
dict_keys_inorder(PyObject *dict, Py_ssize_t offset)
{
    PyObject *tuple, *k, *v;
    Py_ssize_t i, pos = 0, size = PyDict_GET_SIZE(dict);

    tuple = PyTuple_New(size);
    if (tuple == NULL)
        return NULL;
    while (PyDict_Next(dict, &pos, &k, &v)) {
        i = PyLong_AS_LONG(v);
        assert((i - offset) < size);
        assert((i - offset) >= 0);
        PyTuple_SET_ITEM(tuple, i - offset, Py_NewRef(k));
    }
    return tuple;
}

// This is in codeobject.c.
extern void _Py_set_localsplus_info(int, PyObject *, unsigned char,
                                   PyObject *, PyObject *);

static void
compute_localsplus_info(_PyCompile_CodeUnitMetadata *umd, int nlocalsplus,
                        PyObject *names, PyObject *kinds)
{
    PyObject *k, *v;
    Py_ssize_t pos = 0;
    while (PyDict_Next(umd->u_varnames, &pos, &k, &v)) {
        int offset = (int)PyLong_AS_LONG(v);
        assert(offset >= 0);
        assert(offset < nlocalsplus);
        // For now we do not distinguish arg kinds.
        _PyLocals_Kind kind = CO_FAST_LOCAL;
        if (PyDict_Contains(umd->u_fasthidden, k)) {
            kind |= CO_FAST_HIDDEN;
        }
        if (PyDict_GetItem(umd->u_cellvars, k) != NULL) {
            kind |= CO_FAST_CELL;
        }
        _Py_set_localsplus_info(offset, k, kind, names, kinds);
    }
    int nlocals = (int)PyDict_GET_SIZE(umd->u_varnames);

    // This counter mirrors the fix done in fix_cell_offsets().
    int numdropped = 0;
    pos = 0;
    while (PyDict_Next(umd->u_cellvars, &pos, &k, &v)) {
        if (PyDict_GetItem(umd->u_varnames, k) != NULL) {
            // Skip cells that are already covered by locals.
            numdropped += 1;
            continue;
        }
        int offset = (int)PyLong_AS_LONG(v);
        assert(offset >= 0);
        offset += nlocals - numdropped;
        assert(offset < nlocalsplus);
        _Py_set_localsplus_info(offset, k, CO_FAST_CELL, names, kinds);
    }

    pos = 0;
    while (PyDict_Next(umd->u_freevars, &pos, &k, &v)) {
        int offset = (int)PyLong_AS_LONG(v);
        assert(offset >= 0);
        offset += nlocals - numdropped;
        assert(offset < nlocalsplus);
        _Py_set_localsplus_info(offset, k, CO_FAST_FREE, names, kinds);
    }
}

static PyCodeObject *
makecode(_PyCompile_CodeUnitMetadata *umd, struct assembler *a, PyObject *const_cache,
         PyObject *constslist, int maxdepth, int nlocalsplus, int code_flags,
         PyObject *filename)
{
    PyCodeObject *co = NULL;
    PyObject *names = NULL;
    PyObject *consts = NULL;
    PyObject *localsplusnames = NULL;
    PyObject *localspluskinds = NULL;
    names = dict_keys_inorder(umd->u_names, 0);
    if (!names) {
        goto error;
    }
    if (_PyCompile_ConstCacheMergeOne(const_cache, &names) < 0) {
        goto error;
    }

    consts = PyList_AsTuple(constslist); /* PyCode_New requires a tuple */
    if (consts == NULL) {
        goto error;
    }
    if (_PyCompile_ConstCacheMergeOne(const_cache, &consts) < 0) {
        goto error;
    }

    assert(umd->u_posonlyargcount < INT_MAX);
    assert(umd->u_argcount < INT_MAX);
    assert(umd->u_kwonlyargcount < INT_MAX);
    int posonlyargcount = (int)umd->u_posonlyargcount;
    int posorkwargcount = (int)umd->u_argcount;
    assert(INT_MAX - posonlyargcount - posorkwargcount > 0);
    int kwonlyargcount = (int)umd->u_kwonlyargcount;

    localsplusnames = PyTuple_New(nlocalsplus);
    if (localsplusnames == NULL) {
        goto error;
    }
    localspluskinds = PyBytes_FromStringAndSize(NULL, nlocalsplus);
    if (localspluskinds == NULL) {
        goto error;
    }
    compute_localsplus_info(umd, nlocalsplus, localsplusnames, localspluskinds);

    struct _PyCodeConstructor con = {
        .filename = filename,
        .name = umd->u_name,
        .qualname = umd->u_qualname ? umd->u_qualname : umd->u_name,
        .flags = code_flags,

        .code = a->a_bytecode,
        .firstlineno = umd->u_firstlineno,
        .linetable = a->a_linetable,

        .consts = consts,
        .names = names,

        .localsplusnames = localsplusnames,
        .localspluskinds = localspluskinds,

        .argcount = posonlyargcount + posorkwargcount,
        .posonlyargcount = posonlyargcount,
        .kwonlyargcount = kwonlyargcount,

        .stacksize = maxdepth,

        .exceptiontable = a->a_except_table,
    };

   if (_PyCode_Validate(&con) < 0) {
        goto error;
    }

    if (_PyCompile_ConstCacheMergeOne(const_cache, &localsplusnames) < 0) {
        goto error;
    }
    con.localsplusnames = localsplusnames;

    co = _PyCode_New(&con);
    if (co == NULL) {
        goto error;
    }

error:
    Py_XDECREF(names);
    Py_XDECREF(consts);
    Py_XDECREF(localsplusnames);
    Py_XDECREF(localspluskinds);
    return co;
}


PyCodeObject *
_PyAssemble_MakeCodeObject(_PyCompile_CodeUnitMetadata *umd, PyObject *const_cache,
                           PyObject *consts, int maxdepth, instr_sequence *instrs,
                           int nlocalsplus, int code_flags, PyObject *filename)
{
    PyCodeObject *co = NULL;

    struct assembler a;
    int res = assemble_emit(&a, instrs, umd->u_firstlineno, const_cache);
    if (res == SUCCESS) {
        co = makecode(umd, &a, const_cache, consts, maxdepth, nlocalsplus,
                      code_flags, filename);
    }
    assemble_free(&a);
    return co;
}


================================================
FILE: Ast.c
================================================
/*
 * This file exposes PyAST_Validate interface to check the integrity
 * of the given abstract syntax tree (potentially constructed manually).
 */
#include "Python.h"
#include "pycore_ast.h"           // asdl_stmt_seq
#include "pycore_pystate.h"       // _PyThreadState_GET()

#include <assert.h>
#include <stdbool.h>

struct validator {
    int recursion_depth;            /* current recursion depth */
    int recursion_limit;            /* recursion limit */
};

static int validate_stmts(struct validator *, asdl_stmt_seq *);
static int validate_exprs(struct validator *, asdl_expr_seq *, expr_context_ty, int);
static int validate_patterns(struct validator *, asdl_pattern_seq *, int);
static int validate_type_params(struct validator *, asdl_type_param_seq *);
static int _validate_nonempty_seq(asdl_seq *, const char *, const char *);
static int validate_stmt(struct validator *, stmt_ty);
static int validate_expr(struct validator *, expr_ty, expr_context_ty);
static int validate_pattern(struct validator *, pattern_ty, int);
static int validate_typeparam(struct validator *, type_param_ty);

#define VALIDATE_POSITIONS(node) \
    if (node->lineno > node->end_lineno) { \
        PyErr_Format(PyExc_ValueError, \
                     "AST node line range (%d, %d) is not valid", \
                     node->lineno, node->end_lineno); \
        return 0; \
    } \
    if ((node->lineno < 0 && node->end_lineno != node->lineno) || \
        (node->col_offset < 0 && node->col_offset != node->end_col_offset)) { \
        PyErr_Format(PyExc_ValueError, \
                     "AST node column range (%d, %d) for line range (%d, %d) is not valid", \
                     node->col_offset, node->end_col_offset, node->lineno, node->end_lineno); \
        return 0; \
    } \
    if (node->lineno == node->end_lineno && node->col_offset > node->end_col_offset) { \
        PyErr_Format(PyExc_ValueError, \
                     "line %d, column %d-%d is not a valid range", \
                     node->lineno, node->col_offset, node->end_col_offset); \
        return 0; \
    }

static int
validate_name(PyObject *name)
{
    assert(!PyErr_Occurred());
    assert(PyUnicode_Check(name));
    static const char * const forbidden[] = {
        "None",
        "True",
        "False",
        NULL
    };
    for (int i = 0; forbidden[i] != NULL; i++) {
        if (_PyUnicode_EqualToASCIIString(name, forbidden[i])) {
            PyErr_Format(PyExc_ValueError, "identifier field can't represent '%s' constant", forbidden[i]);
            return 0;
        }
    }
    return 1;
}

static int
validate_comprehension(struct validator *state, asdl_comprehension_seq *gens)
{
    assert(!PyErr_Occurred());
    if (!asdl_seq_LEN(gens)) {
        PyErr_SetString(PyExc_ValueError, "comprehension with no generators");
        return 0;
    }
    for (Py_ssize_t i = 0; i < asdl_seq_LEN(gens); i++) {
        comprehension_ty comp = asdl_seq_GET(gens, i);
        if (!validate_expr(state, comp->target, Store) ||
            !validate_expr(state, comp->iter, Load) ||
            !validate_exprs(state, comp->ifs, Load, 0))
            return 0;
    }
    return 1;
}

static int
validate_keywords(struct validator *state, asdl_keyword_seq *keywords)
{
    assert(!PyErr_Occurred());
    for (Py_ssize_t i = 0; i < asdl_seq_LEN(keywords); i++)
        if (!validate_expr(state, (asdl_seq_GET(keywords, i))->value, Load))
            return 0;
    return 1;
}

static int
validate_args(struct validator *state, asdl_arg_seq *args)
{
    assert(!PyErr_Occurred());
    for (Py_ssize_t i = 0; i < asdl_seq_LEN(args); i++) {
        arg_ty arg = asdl_seq_GET(args, i);
        VALIDATE_POSITIONS(arg);
        if (arg->annotation && !validate_expr(state, arg->annotation, Load))
            return 0;
    }
    return 1;
}

static const char *
expr_context_name(expr_context_ty ctx)
{
    switch (ctx) {
    case Load:
        return "Load";
    case Store:
        return "Store";
    case Del:
        return "Del";
    // No default case so compiler emits warning for unhandled cases
    }
    Py_UNREACHABLE();
}

static int
validate_arguments(struct validator *state, arguments_ty args)
{
    assert(!PyErr_Occurred());
    if (!validate_args(state, args->posonlyargs) || !validate_args(state, args->args)) {
        return 0;
    }
    if (args->vararg && args->vararg->annotation
        && !validate_expr(state, args->vararg->annotation, Load)) {
            return 0;
    }
    if (!validate_args(state, args->kwonlyargs))
        return 0;
    if (args->kwarg && args->kwarg->annotation
        && !validate_expr(state, args->kwarg->annotation, Load)) {
            return 0;
    }
    if (asdl_seq_LEN(args->defaults) > asdl_seq_LEN(args->posonlyargs) + asdl_seq_LEN(args->args)) {
        PyErr_SetString(PyExc_ValueError, "more positional defaults than args on arguments");
        return 0;
    }
    if (asdl_seq_LEN(args->kw_defaults) != asdl_seq_LEN(args->kwonlyargs)) {
        PyErr_SetString(PyExc_ValueError, "length of kwonlyargs is not the same as "
                        "kw_defaults on arguments");
        return 0;
    }
    return validate_exprs(state, args->defaults, Load, 0) && validate_exprs(state, args->kw_defaults, Load, 1);
}

static int
validate_constant(struct validator *state, PyObject *value)
{
    assert(!PyErr_Occurred());
    if (value == Py_None || value == Py_Ellipsis)
        return 1;

    if (PyLong_CheckExact(value)
            || PyFloat_CheckExact(value)
            || PyComplex_CheckExact(value)
            || PyBool_Check(value)
            || PyUnicode_CheckExact(value)
            || PyBytes_CheckExact(value))
        return 1;

    if (PyTuple_CheckExact(value) || PyFrozenSet_CheckExact(value)) {
        if (++state->recursion_depth > state->recursion_limit) {
            PyErr_SetString(PyExc_RecursionError,
                            "maximum recursion depth exceeded during compilation");
            return 0;
        }

        PyObject *it = PyObject_GetIter(value);
        if (it == NULL)
            return 0;

        while (1) {
            PyObject *item = PyIter_Next(it);
            if (item == NULL) {
                if (PyErr_Occurred()) {
                    Py_DECREF(it);
                    return 0;
                }
                break;
            }

            if (!validate_constant(state, item)) {
                Py_DECREF(it);
                Py_DECREF(item);
                return 0;
            }
            Py_DECREF(item);
        }

        Py_DECREF(it);
        --state->recursion_depth;
        return 1;
    }

    if (!PyErr_Occurred()) {
        PyErr_Format(PyExc_TypeError,
                     "got an invalid type in Constant: %s",
                     _PyType_Name(Py_TYPE(value)));
    }
    return 0;
}

static int
validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx)
{
    assert(!PyErr_Occurred());
    VALIDATE_POSITIONS(exp);
    int ret = -1;
    if (++state->recursion_depth > state->recursion_limit) {
        PyErr_SetString(PyExc_RecursionError,
                        "maximum recursion depth exceeded during compilation");
        return 0;
    }
    int check_ctx = 1;
    expr_context_ty actual_ctx;

    /* First check expression context. */
    switch (exp->kind) {
    case Attribute_kind:
        actual_ctx = exp->v.Attribute.ctx;
        break;
    case Subscript_kind:
        actual_ctx = exp->v.Subscript.ctx;
        break;
    case Starred_kind:
        actual_ctx = exp->v.Starred.ctx;
        break;
    case Name_kind:
        if (!validate_name(exp->v.Name.id)) {
            return 0;
        }
        actual_ctx = exp->v.Name.ctx;
        break;
    case List_kind:
        actual_ctx = exp->v.List.ctx;
        break;
    case Tuple_kind:
        actual_ctx = exp->v.Tuple.ctx;
        break;
    default:
        if (ctx != Load) {
            PyErr_Format(PyExc_ValueError, "expression which can't be "
                         "assigned to in %s context", expr_context_name(ctx));
            return 0;
        }
        check_ctx = 0;
        /* set actual_ctx to prevent gcc warning */
        actual_ctx = 0;
    }
    if (check_ctx && actual_ctx != ctx) {
        PyErr_Format(PyExc_ValueError, "expression must have %s context but has %s instead",
                     expr_context_name(ctx), expr_context_name(actual_ctx));
        return 0;
    }

    /* Now validate expression. */
    switch (exp->kind) {
    case BoolOp_kind:
        if (asdl_seq_LEN(exp->v.BoolOp.values) < 2) {
            PyErr_SetString(PyExc_ValueError, "BoolOp with less than 2 values");
            return 0;
        }
        ret = validate_exprs(state, exp->v.BoolOp.values, Load, 0);
        break;
    case BinOp_kind:
        ret = validate_expr(state, exp->v.BinOp.left, Load) &&
            validate_expr(state, exp->v.BinOp.right, Load);
        break;
    case UnaryOp_kind:
        ret = validate_expr(state, exp->v.UnaryOp.operand, Load);
        break;
    case Lambda_kind:
        ret = validate_arguments(state, exp->v.Lambda.args) &&
            validate_expr(state, exp->v.Lambda.body, Load);
        break;
    case IfExp_kind:
        ret = validate_expr(state, exp->v.IfExp.test, Load) &&
            validate_expr(state, exp->v.IfExp.body, Load) &&
            validate_expr(state, exp->v.IfExp.orelse, Load);
        break;
    case Dict_kind:
        if (asdl_seq_LEN(exp->v.Dict.keys) != asdl_seq_LEN(exp->v.Dict.values)) {
            PyErr_SetString(PyExc_ValueError,
                            "Dict doesn't have the same number of keys as values");
            return 0;
        }
        /* null_ok=1 for keys expressions to allow dict unpacking to work in
           dict literals, i.e. ``{**{a:b}}`` */
        ret = validate_exprs(state, exp->v.Dict.keys, Load, /*null_ok=*/ 1) &&
            validate_exprs(state, exp->v.Dict.values, Load, /*null_ok=*/ 0);
        break;
    case Set_kind:
        ret = validate_exprs(state, exp->v.Set.elts, Load, 0);
        break;
#define COMP(NAME) \
        case NAME ## _kind: \
            ret = validate_comprehension(state, exp->v.NAME.generators) && \
                validate_expr(state, exp->v.NAME.elt, Load); \
            break;
    COMP(ListComp)
    COMP(SetComp)
    COMP(GeneratorExp)
#undef COMP
    case DictComp_kind:
        ret = validate_comprehension(state, exp->v.DictComp.generators) &&
            validate_expr(state, exp->v.DictComp.key, Load) &&
            validate_expr(state, exp->v.DictComp.value, Load);
        break;
    case Yield_kind:
        ret = !exp->v.Yield.value || validate_expr(state, exp->v.Yield.value, Load);
        break;
    case YieldFrom_kind:
        ret = validate_expr(state, exp->v.YieldFrom.value, Load);
        break;
    case Await_kind:
        ret = validate_expr(state, exp->v.Await.value, Load);
        break;
    case Compare_kind:
        if (!asdl_seq_LEN(exp->v.Compare.comparators)) {
            PyErr_SetString(PyExc_ValueError, "Compare with no comparators");
            return 0;
        }
        if (asdl_seq_LEN(exp->v.Compare.comparators) !=
            asdl_seq_LEN(exp->v.Compare.ops)) {
            PyErr_SetString(PyExc_ValueError, "Compare has a different number "
                            "of comparators and operands");
            return 0;
        }
        ret = validate_exprs(state, exp->v.Compare.comparators, Load, 0) &&
            validate_expr(state, exp->v.Compare.left, Load);
        break;
    case Call_kind:
        ret = validate_expr(state, exp->v.Call.func, Load) &&
            validate_exprs(state, exp->v.Call.args, Load, 0) &&
            validate_keywords(state, exp->v.Call.keywords);
        break;
    case Constant_kind:
        if (!validate_constant(state, exp->v.Constant.value)) {
            return 0;
        }
        ret = 1;
        break;
    case JoinedStr_kind:
        ret = validate_exprs(state, exp->v.JoinedStr.values, Load, 0);
        break;
    case FormattedValue_kind:
        if (validate_expr(state, exp->v.FormattedValue.value, Load) == 0)
            return 0;
        if (exp->v.FormattedValue.format_spec) {
            ret = validate_expr(state, exp->v.FormattedValue.format_spec, Load);
            break;
        }
        ret = 1;
        break;
    case Attribute_kind:
        ret = validate_expr(state, exp->v.Attribute.value, Load);
        break;
    case Subscript_kind:
        ret = validate_expr(state, exp->v.Subscript.slice, Load) &&
            validate_expr(state, exp->v.Subscript.value, Load);
        break;
    case Starred_kind:
        ret = validate_expr(state, exp->v.Starred.value, ctx);
        break;
    case Slice_kind:
        ret = (!exp->v.Slice.lower || validate_expr(state, exp->v.Slice.lower, Load)) &&
            (!exp->v.Slice.upper || validate_expr(state, exp->v.Slice.upper, Load)) &&
            (!exp->v.Slice.step || validate_expr(state, exp->v.Slice.step, Load));
        break;
    case List_kind:
        ret = validate_exprs(state, exp->v.List.elts, ctx, 0);
        break;
    case Tuple_kind:
        ret = validate_exprs(state, exp->v.Tuple.elts, ctx, 0);
        break;
    case NamedExpr_kind:
        ret = validate_expr(state, exp->v.NamedExpr.value, Load);
        break;
    /* This last case doesn't have any checking. */
    case Name_kind:
        ret = 1;
        break;
    // No default case so compiler emits warning for unhandled cases
    }
    if (ret < 0) {
        PyErr_SetString(PyExc_SystemError, "unexpected expression");
        ret = 0;
    }
    state->recursion_depth--;
    return ret;
}


// Note: the ensure_literal_* functions are only used to validate a restricted
//       set of non-recursive literals that have already been checked with
//       validate_expr, so they don't accept the validator state
static int
ensure_literal_number(expr_ty exp, bool allow_real, bool allow_imaginary)
{
    assert(exp->kind == Constant_kind);
    PyObject *value = exp->v.Constant.value;
    return (allow_real && PyFloat_CheckExact(value)) ||
           (allow_real && PyLong_CheckExact(value)) ||
           (allow_imaginary && PyComplex_CheckExact(value));
}

static int
ensure_literal_negative(expr_ty exp, bool allow_real, bool allow_imaginary)
{
    assert(exp->kind == UnaryOp_kind);
    // Must be negation ...
    if (exp->v.UnaryOp.op != USub) {
        return 0;
    }
    // ... of a constant ...
    expr_ty operand = exp->v.UnaryOp.operand;
    if (operand->kind != Constant_kind) {
        return 0;
    }
    // ... number
    return ensure_literal_number(operand, allow_real, allow_imaginary);
}

static int
ensure_literal_complex(expr_ty exp)
{
    assert(exp->kind == BinOp_kind);
    expr_ty left = exp->v.BinOp.left;
    expr_ty right = exp->v.BinOp.right;
    // Ensure op is addition or subtraction
    if (exp->v.BinOp.op != Add && exp->v.BinOp.op != Sub) {
        return 0;
    }
    // Check LHS is a real number (potentially signed)
    switch (left->kind)
    {
        case Constant_kind:
            if (!ensure_literal_number(left, /*real=*/true, /*imaginary=*/false)) {
                return 0;
            }
            break;
        case UnaryOp_kind:
            if (!ensure_literal_negative(left, /*real=*/true, /*imaginary=*/false)) {
                return 0;
            }
            break;
        default:
            return 0;
    }
    // Check RHS is an imaginary number (no separate sign allowed)
    switch (right->kind)
    {
        case Constant_kind:
            if (!ensure_literal_number(right, /*real=*/false, /*imaginary=*/true)) {
                return 0;
            }
            break;
        default:
            return 0;
    }
    return 1;
}

static int
validate_pattern_match_value(struct validator *state, expr_ty exp)
{
    assert(!PyErr_Occurred());
    if (!validate_expr(state, exp, Load)) {
        return 0;
    }

    switch (exp->kind)
    {
        case Constant_kind:
            /* Ellipsis and immutable sequences are not allowed.
               For True, False and None, MatchSingleton() should
               be used */
            if (!validate_expr(state, exp, Load)) {
                return 0;
            }
            PyObject *literal = exp->v.Constant.value;
            if (PyLong_CheckExact(literal) || PyFloat_CheckExact(literal) ||
                PyBytes_CheckExact(literal) || PyComplex_CheckExact(literal) ||
                PyUnicode_CheckExact(literal)) {
                return 1;
            }
            PyErr_SetString(PyExc_ValueError,
                            "unexpected constant inside of a literal pattern");
            return 0;
        case Attribute_kind:
            // Constants and attribute lookups are always permitted
            return 1;
        case UnaryOp_kind:
            // Negated numbers are permitted (whether real or imaginary)
            // Compiler will complain if AST folding doesn't create a constant
            if (ensure_literal_negative(exp, /*real=*/true, /*imaginary=*/true)) {
                return 1;
            }
            break;
        case BinOp_kind:
            // Complex literals are permitted
            // Compiler will complain if AST folding doesn't create a constant
            if (ensure_literal_complex(exp)) {
                return 1;
            }
            break;
        case JoinedStr_kind:
            // Handled in the later stages
            return 1;
        default:
            break;
    }
    PyErr_SetString(PyExc_ValueError,
                    "patterns may only match literals and attribute lookups");
    return 0;
}

static int
validate_capture(PyObject *name)
{
    assert(!PyErr_Occurred());
    if (_PyUnicode_EqualToASCIIString(name, "_")) {
        PyErr_Format(PyExc_ValueError, "can't capture name '_' in patterns");
        return 0;
    }
    return validate_name(name);
}

static int
validate_pattern(struct validator *state, pattern_ty p, int star_ok)
{
    assert(!PyErr_Occurred());
    VALIDATE_POSITIONS(p);
    int ret = -1;
    if (++state->recursion_depth > state->recursion_limit) {
        PyErr_SetString(PyExc_RecursionError,
                        "maximum recursion depth exceeded during compilation");
        return 0;
    }
    switch (p->kind) {
        case MatchValue_kind:
            ret = validate_pattern_match_value(state, p->v.MatchValue.value);
            break;
        case MatchSingleton_kind:
            ret = p->v.MatchSingleton.value == Py_None || PyBool_Check(p->v.MatchSingleton.value);
            if (!ret) {
                PyErr_SetString(PyExc_ValueError,
                                "MatchSingleton can only contain True, False and None");
            }
            break;
        case MatchSequence_kind:
            ret = validate_patterns(state, p->v.MatchSequence.patterns, /*star_ok=*/1);
            break;
        case MatchMapping_kind:
            if (asdl_seq_LEN(p->v.MatchMapping.keys) != asdl_seq_LEN(p->v.MatchMapping.patterns)) {
                PyErr_SetString(PyExc_ValueError,
                                "MatchMapping doesn't have the same number of keys as patterns");
                ret = 0;
                break;
            }

            if (p->v.MatchMapping.rest && !validate_capture(p->v.MatchMapping.rest)) {
                ret = 0;
                break;
            }

            asdl_expr_seq *keys = p->v.MatchMapping.keys;
            for (Py_ssize_t i = 0; i < asdl_seq_LEN(keys); i++) {
                expr_ty key = asdl_seq_GET(keys, i);
                if (key->kind == Constant_kind) {
                    PyObject *literal = key->v.Constant.value;
                    if (literal == Py_None || PyBool_Check(literal)) {
                        /* validate_pattern_match_value will ensure the key
                           doesn't contain True, False and None but it is
                           syntactically valid, so we will pass those on in
                           a special case. */
                        continue;
                    }
                }
                if (!validate_pattern_match_value(state, key)) {
                    ret = 0;
                    break;
                }
            }
            if (ret == 0) {
                break;
            }
            ret = validate_patterns(state, p->v.MatchMapping.patterns, /*star_ok=*/0);
            break;
        case MatchClass_kind:
            if (asdl_seq_LEN(p->v.MatchClass.kwd_attrs) != asdl_seq_LEN(p->v.MatchClass.kwd_patterns)) {
                PyErr_SetString(PyExc_ValueError,
                                "MatchClass doesn't have the same number of keyword attributes as patterns");
                ret = 0;
                break;
            }
            if (!validate_expr(state, p->v.MatchClass.cls, Load)) {
                ret = 0;
                break;
            }

            expr_ty cls = p->v.MatchClass.cls;
            while (1) {
                if (cls->kind == Name_kind) {
                    break;
                }
                else if (cls->kind == Attribute_kind) {
                    cls = cls->v.Attribute.value;
                    continue;
                }
                else {
                    PyErr_SetString(PyExc_ValueError,
                                    "MatchClass cls field can only contain Name or Attribute nodes.");
                    ret = 0;
                    break;
                }
            }
            if (ret == 0) {
                break;
            }

            for (Py_ssize_t i = 0; i < asdl_seq_LEN(p->v.MatchClass.kwd_attrs); i++) {
                PyObject *identifier = asdl_seq_GET(p->v.MatchClass.kwd_attrs, i);
                if (!validate_name(identifier)) {
                    ret = 0;
                    break;
                }
            }
            if (ret == 0) {
                break;
            }

            if (!validate_patterns(state, p->v.MatchClass.patterns, /*star_ok=*/0)) {
                ret = 0;
                break;
            }

            ret = validate_patterns(state, p->v.MatchClass.kwd_patterns, /*star_ok=*/0);
            break;
        case MatchStar_kind:
            if (!star_ok) {
                PyErr_SetString(PyExc_ValueError, "can't use MatchStar here");
                ret = 0;
                break;
            }
            ret = p->v.MatchStar.name == NULL || validate_capture(p->v.MatchStar.name);
            break;
        case MatchAs_kind:
            if (p->v.MatchAs.name && !validate_capture(p->v.MatchAs.name)) {
                ret = 0;
                break;
            }
            if (p->v.MatchAs.pattern == NULL) {
                ret = 1;
            }
            else if (p->v.MatchAs.name == NULL) {
                PyErr_SetString(PyExc_ValueError,
                                "MatchAs must specify a target name if a pattern is given");
                ret = 0;
            }
            else {
                ret = validate_pattern(state, p->v.MatchAs.pattern, /*star_ok=*/0);
            }
            break;
        case MatchOr_kind:
            if (asdl_seq_LEN(p->v.MatchOr.patterns) < 2) {
                PyErr_SetString(PyExc_ValueError,
                                "MatchOr requires at least 2 patterns");
                ret = 0;
                break;
            }
            ret = validate_patterns(state, p->v.MatchOr.patterns, /*star_ok=*/0);
            break;
    // No default case, so the compiler will emit a warning if new pattern
    // kinds are added without being handled here
    }
    if (ret < 0) {
        PyErr_SetString(PyExc_SystemError, "unexpected pattern");
        ret = 0;
    }
    state->recursion_depth--;
    return ret;
}

static int
_validate_nonempty_seq(asdl_seq *seq, const char *what, const char *owner)
{
    if (asdl_seq_LEN(seq))
        return 1;
    PyErr_Format(PyExc_ValueError, "empty %s on %s", what, owner);
    return 0;
}
#define validate_nonempty_seq(seq, what, owner) _validate_nonempty_seq((asdl_seq*)seq, what, owner)

static int
validate_assignlist(struct validator *state, asdl_expr_seq *targets, expr_context_ty ctx)
{
    assert(!PyErr_Occurred());
    return validate_nonempty_seq(targets, "targets", ctx == Del ? "Delete" : "Assign") &&
        validate_exprs(state, targets, ctx, 0);
}

static int
validate_body(struct validator *state, asdl_stmt_seq *body, const char *owner)
{
    assert(!PyErr_Occurred());
    return validate_nonempty_seq(body, "body", owner) && validate_stmts(state, body);
}

static int
validate_stmt(struct validator *state, stmt_ty stmt)
{
    assert(!PyErr_Occurred());
    VALIDATE_POSITIONS(stmt);
    int ret = -1;
    if (++state->recursion_depth > state->recursion_limit) {
        PyErr_SetString(PyExc_RecursionError,
                        "maximum recursion depth exceeded during compilation");
        return 0;
    }
    switch (stmt->kind) {
    case FunctionDef_kind:
        ret = validate_body(state, stmt->v.FunctionDef.body, "FunctionDef") &&
            validate_type_params(state, stmt->v.FunctionDef.type_params) &&
            validate_arguments(state, stmt->v.FunctionDef.args) &&
            validate_exprs(state, stmt->v.FunctionDef.decorator_list, Load, 0) &&
            (!stmt->v.FunctionDef.returns ||
             validate_expr(state, stmt->v.FunctionDef.returns, Load));
        break;
    case ClassDef_kind:
        ret = validate_body(state, stmt->v.ClassDef.body, "ClassDef") &&
            validate_type_params(state, stmt->v.ClassDef.type_params) &&
            validate_exprs(state, stmt->v.ClassDef.bases, Load, 0) &&
            validate_keywords(state, stmt->v.ClassDef.keywords) &&
            validate_exprs(state, stmt->v.ClassDef.decorator_list, Load, 0);
        break;
    case Return_kind:
        ret = !stmt->v.Return.value || validate_expr(state, stmt->v.Return.value, Load);
        break;
    case Delete_kind:
        ret = validate_assignlist(state, stmt->v.Delete.targets, Del);
        break;
    case Assign_kind:
        ret = validate_assignlist(state, stmt->v.Assign.targets, Store) &&
            validate_expr(state, stmt->v.Assign.value, Load);
        break;
    case AugAssign_kind:
        ret = validate_expr(state, stmt->v.AugAssign.target, Store) &&
            validate_expr(state, stmt->v.AugAssign.value, Load);
        break;
    case AnnAssign_kind:
        if (stmt->v.AnnAssign.target->kind != Name_kind &&
            stmt->v.AnnAssign.simple) {
            PyErr_SetString(PyExc_TypeError,
                            "AnnAssign with simple non-Name target");
            return 0;
        }
        ret = validate_expr(state, stmt->v.AnnAssign.target, Store) &&
               (!stmt->v.AnnAssign.value ||
                validate_expr(state, stmt->v.AnnAssign.value, Load)) &&
               validate_expr(state, stmt->v.AnnAssign.annotation, Load);
        break;
    case TypeAlias_kind:
        ret = validate_expr(state, stmt->v.TypeAlias.name, Store) &&
            validate_type_params(state, stmt->v.TypeAlias.type_params) &&
            validate_expr(state, stmt->v.TypeAlias.value, Load);
        break;
    case For_kind:
        ret = validate_expr(state, stmt->v.For.target, Store) &&
            validate_expr(state, stmt->v.For.iter, Load) &&
            validate_body(state, stmt->v.For.body, "For") &&
            validate_stmts(state, stmt->v.For.orelse);
        break;
    case AsyncFor_kind:
        ret = validate_expr(state, stmt->v.AsyncFor.target, Store) &&
            validate_expr(state, stmt->v.AsyncFor.iter, Load) &&
            validate_body(state, stmt->v.AsyncFor.body, "AsyncFor") &&
            validate_stmts(state, stmt->v.AsyncFor.orelse);
        break;
    case While_kind:
        ret = validate_expr(state, stmt->v.While.test, Load) &&
            validate_body(state, stmt->v.While.body, "While") &&
            validate_stmts(state, stmt->v.While.orelse);
        break;
    case If_kind:
        ret = validate_expr(state, stmt->v.If.test, Load) &&
            validate_body(state, stmt->v.If.body, "If") &&
            validate_stmts(state, stmt->v.If.orelse);
        break;
    case With_kind:
        if (!validate_nonempty_seq(stmt->v.With.items, "items", "With"))
            return 0;
        for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.With.items); i++) {
            withitem_ty item = asdl_seq_GET(stmt->v.With.items, i);
            if (!validate_expr(state, item->context_expr, Load) ||
                (item->optional_vars && !validate_expr(state, item->optional_vars, Store)))
                return 0;
        }
        ret = validate_body(state, stmt->v.With.body, "With");
        break;
    case AsyncWith_kind:
        if (!validate_nonempty_seq(stmt->v.AsyncWith.items, "items", "AsyncWith"))
            return 0;
        for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.AsyncWith.items); i++) {
            withitem_ty item = asdl_seq_GET(stmt->v.AsyncWith.items, i);
            if (!validate_expr(state, item->context_expr, Load) ||
                (item->optional_vars && !validate_expr(state, item->optional_vars, Store)))
                return 0;
        }
        ret = validate_body(state, stmt->v.AsyncWith.body, "AsyncWith");
        break;
    case Match_kind:
        if (!validate_expr(state, stmt->v.Match.subject, Load)
            || !validate_nonempty_seq(stmt->v.Match.cases, "cases", "Match")) {
            return 0;
        }
        for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.Match.cases); i++) {
            match_case_ty m = asdl_seq_GET(stmt->v.Match.cases, i);
            if (!validate_pattern(state, m->pattern, /*star_ok=*/0)
                || (m->guard && !validate_expr(state, m->guard, Load))
                || !validate_body(state, m->body, "match_case")) {
                return 0;
            }
        }
        ret = 1;
        break;
    case Raise_kind:
        if (stmt->v.Raise.exc) {
            ret = validate_expr(state, stmt->v.Raise.exc, Load) &&
                (!stmt->v.Raise.cause || validate_expr(state, stmt->v.Raise.cause, Load));
            break;
        }
        if (stmt->v.Raise.cause) {
            PyErr_SetString(PyExc_ValueError, "Raise with cause but no exception");
            return 0;
        }
        ret = 1;
        break;
    case Try_kind:
        if (!validate_body(state, stmt->v.Try.body, "Try"))
            return 0;
        if (!asdl_seq_LEN(stmt->v.Try.handlers) &&
            !asdl_seq_LEN(stmt->v.Try.finalbody)) {
            PyErr_SetString(PyExc_ValueError, "Try has neither except handlers nor finalbody");
            return 0;
        }
        if (!asdl_seq_LEN(stmt->v.Try.handlers) &&
            asdl_seq_LEN(stmt->v.Try.orelse)) {
            PyErr_SetString(PyExc_ValueError, "Try has orelse but no except handlers");
            return 0;
        }
        for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.Try.handlers); i++) {
            excepthandler_ty handler = asdl_seq_GET(stmt->v.Try.handlers, i);
            VALIDATE_POSITIONS(handler);
            if ((handler->v.ExceptHandler.type &&
                 !validate_expr(state, handler->v.ExceptHandler.type, Load)) ||
                !validate_body(state, handler->v.ExceptHandler.body, "ExceptHandler"))
                return 0;
        }
        ret = (!asdl_seq_LEN(stmt->v.Try.finalbody) ||
                validate_stmts(state, stmt->v.Try.finalbody)) &&
            (!asdl_seq_LEN(stmt->v.Try.orelse) ||
             validate_stmts(state, stmt->v.Try.orelse));
        break;
    case TryStar_kind:
        if (!validate_body(state, stmt->v.TryStar.body, "TryStar"))
            return 0;
        if (!asdl_seq_LEN(stmt->v.TryStar.handlers) &&
            !asdl_seq_LEN(stmt->v.TryStar.finalbody)) {
            PyErr_SetString(PyExc_ValueError, "TryStar has neither except handlers nor finalbody");
            return 0;
        }
        if (!asdl_seq_LEN(stmt->v.TryStar.handlers) &&
            asdl_seq_LEN(stmt->v.TryStar.orelse)) {
            PyErr_SetString(PyExc_ValueError, "TryStar has orelse but no except handlers");
            return 0;
        }
        for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.TryStar.handlers); i++) {
            excepthandler_ty handler = asdl_seq_GET(stmt->v.TryStar.handlers, i);
            if ((handler->v.ExceptHandler.type &&
                 !validate_expr(state, handler->v.ExceptHandler.type, Load)) ||
                !validate_body(state, handler->v.ExceptHandler.body, "ExceptHandler"))
                return 0;
        }
        ret = (!asdl_seq_LEN(stmt->v.TryStar.finalbody) ||
                validate_stmts(state, stmt->v.TryStar.finalbody)) &&
            (!asdl_seq_LEN(stmt->v.TryStar.orelse) ||
             validate_stmts(state, stmt->v.TryStar.orelse));
        break;
    case Assert_kind:
        ret = validate_expr(state, stmt->v.Assert.test, Load) &&
            (!stmt->v.Assert.msg || validate_expr(state, stmt->v.Assert.msg, Load));
        break;
    case Import_kind:
        ret = validate_nonempty_seq(stmt->v.Import.names, "names", "Import");
        break;
    case ImportFrom_kind:
        if (stmt->v.ImportFrom.level < 0) {
            PyErr_SetString(PyExc_ValueError, "Negative ImportFrom level");
            return 0;
        }
        ret = validate_nonempty_seq(stmt->v.ImportFrom.names, "names", "ImportFrom");
        break;
    case Global_kind:
        ret = validate_nonempty_seq(stmt->v.Global.names, "names", "Global");
        break;
    case Nonlocal_kind:
        ret = validate_nonempty_seq(stmt->v.Nonlocal.names, "names", "Nonlocal");
        break;
    case Expr_kind:
        ret = validate_expr(state, stmt->v.Expr.value, Load);
        break;
    case AsyncFunctionDef_kind:
        ret = validate_body(state, stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") &&
            validate_type_params(state, stmt->v.AsyncFunctionDef.type_params) &&
            validate_arguments(state, stmt->v.AsyncFunctionDef.args) &&
            validate_exprs(state, stmt->v.AsyncFunctionDef.decorator_list, Load, 0) &&
            (!stmt->v.AsyncFunctionDef.returns ||
             validate_expr(state, stmt->v.AsyncFunctionDef.returns, Load));
        break;
    case Pass_kind:
    case Break_kind:
    case Continue_kind:
        ret = 1;
        break;
    // No default case so compiler emits warning for unhandled cases
    }
    if (ret < 0) {
        PyErr_SetString(PyExc_SystemError, "unexpected statement");
        ret = 0;
    }
    state->recursion_depth--;
    return ret;
}

static int
validate_stmts(struct validator *state, asdl_stmt_seq *seq)
{
    assert(!PyErr_Occurred());
    for (Py_ssize_t i = 0; i < asdl_seq_LEN(seq); i++) {
        stmt_ty stmt = asdl_seq_GET(seq, i);
        if (stmt) {
            if (!validate_stmt(state, stmt))
                return 0;
        }
        else {
            PyErr_SetString(PyExc_ValueError,
                            "None disallowed in statement list");
            return 0;
        }
    }
    return 1;
}

static int
validate_exprs(struct validator *state, asdl_expr_seq *exprs, expr_context_ty ctx, int null_ok)
{
    assert(!PyErr_Occurred());
    for (Py_ssize_t i = 0; i < asdl_seq_LEN(exprs); i++) {
        expr_ty expr = asdl_seq_GET(exprs, i);
        if (expr) {
            if (!validate_expr(state, expr, ctx))
                return 0;
        }
        else if (!null_ok) {
            PyErr_SetString(PyExc_ValueError,
                            "None disallowed in expression list");
            return 0;
        }

    }
    return 1;
}

static int
validate_patterns(struct validator *state, asdl_pattern_seq *patterns, int star_ok)
{
    assert(!PyErr_Occurred());
    for (Py_ssize_t i = 0; i < asdl_seq_LEN(patterns); i++) {
        pattern_ty pattern = asdl_seq_GET(patterns, i);
        if (!validate_pattern(state, pattern, star_ok)) {
            return 0;
        }
    }
    return 1;
}

static int
validate_typeparam(struct validator *state, type_param_ty tp)
{
    VALIDATE_POSITIONS(tp);
    int ret = -1;
    switch (tp->kind) {
        case TypeVar_kind:
            ret = validate_name(tp->v.TypeVar.name) &&
                (!tp->v.TypeVar.bound ||
                 validate_expr(state, tp->v.TypeVar.bound, Load));
            break;
        case ParamSpec_kind:
            ret = validate_name(tp->v.ParamSpec.name);
            break;
        case TypeVarTuple_kind:
            ret = validate_name(tp->v.TypeVarTuple.name);
            break;
    }
    return ret;
}

static int
validate_type_params(struct validator *state, asdl_type_param_seq *tps)
{
    Py_ssize_t i;
    for (i = 0; i < asdl_seq_LEN(tps); i++) {
        type_param_ty tp = asdl_seq_GET(tps, i);
        if (tp) {
            if (!validate_typeparam(state, tp))
                return 0;
        }
    }
    return 1;
}


/* See comments in symtable.c. */
#define COMPILER_STACK_FRAME_SCALE 3

int
_PyAST_Validate(mod_ty mod)
{
    assert(!PyErr_Occurred());
    int res = -1;
    struct validator state;
    PyThreadState *tstate;
    int starting_recursion_depth;

    /* Setup recursion depth check counters */
    tstate = _PyThreadState_GET();
    if (!tstate) {
        return 0;
    }
    /* Be careful here to prevent overflow. */
    int recursion_depth = C_RECURSION_LIMIT - tstate->c_recursion_remaining;
    starting_recursion_depth = recursion_depth * COMPILER_STACK_FRAME_SCALE;
    state.recursion_depth = starting_recursion_depth;
    state.recursion_limit = C_RECURSION_LIMIT * COMPILER_STACK_FRAME_SCALE;

    switch (mod->kind) {
    case Module_kind:
        res = validate_stmts(&state, mod->v.Module.body);
        break;
    case Interactive_kind:
        res = validate_stmts(&state, mod->v.Interactive.body);
        break;
    case Expression_kind:
        res = validate_expr(&state, mod->v.Expression.body, Load);
        break;
    case FunctionType_kind:
        res = validate_exprs(&state, mod->v.FunctionType.argtypes, Load, /*null_ok=*/0) &&
              validate_expr(&state, mod->v.FunctionType.returns, Load);
        break;
    // No default case so compiler emits warning for unhandled cases
    }

    if (res < 0) {
        PyErr_SetString(PyExc_SystemError, "impossible module node");
        return 0;
    }

    /* Check that the recursion depth counting balanced correctly */
    if (res && state.recursion_depth != starting_recursion_depth) {
        PyErr_Format(PyExc_SystemError,
            "AST validator recursion depth mismatch (before=%d, after=%d)",
            starting_recursion_depth, state.recursion_depth);
        return 0;
    }
    return res;
}

PyObject *
_PyAST_GetDocString(asdl_stmt_seq *body)
{
    if (!asdl_seq_LEN(body)) {
        return NULL;
    }
    stmt_ty st = asdl_seq_GET(body, 0);
    if (st->kind != Expr_kind) {
        return NULL;
    }
    expr_ty e = st->v.Expr.value;
    if (e->kind == Constant_kind && PyUnicode_CheckExact(e->v.Constant.value)) {
        return e->v.Constant.value;
    }
    return NULL;
}


================================================
FILE: Ast_Opt.c
================================================
/* AST Optimizer */
#include "Python.h"
#include "pycore_ast.h"           // _PyAST_GetDocString()
#include "pycore_long.h"           // _PyLong
#include "pycore_pystate.h"       // _PyThreadState_GET()
#include "pycore_format.h"        // F_LJUST


typedef struct {
    int optimize;
    int ff_features;

    int recursion_depth;            /* current recursion depth */
    int recursion_limit;            /* recursion limit */
} _PyASTOptimizeState;


static int
make_const(expr_ty node, PyObject *val, PyArena *arena)
{
    // Even if no new value was calculated, make_const may still
    // need to clear an error (e.g. for division by zero)
    if (val == NULL) {
        if (PyErr_ExceptionMatches(PyExc_KeyboardInterrupt)) {
            return 0;
        }
        PyErr_Clear();
        return 1;
    }
    if (_PyArena_AddPyObject(arena, val) < 0) {
        Py_DECREF(val);
        return 0;
    }
    node->kind = Constant_kind;
    node->v.Constant.kind = NULL;
    node->v.Constant.value = val;
    return 1;
}

#define COPY_NODE(TO, FROM) (memcpy((TO), (FROM), sizeof(struct _expr)))

static int
has_starred(asdl_expr_seq *elts)
{
    Py_ssize_t n = asdl_seq_LEN(elts);
    for (Py_ssize_t i = 0; i < n; i++) {
        expr_ty e = (expr_ty)asdl_seq_GET(elts, i);
        if (e->kind == Starred_kind) {
            return 1;
        }
    }
    return 0;
}


static PyObject*
unary_not(PyObject *v)
{
    int r = PyObject_IsTrue(v);
    if (r < 0)
        return NULL;
    return PyBool_FromLong(!r);
}

static int
fold_unaryop(expr_ty node, PyArena *arena, _PyASTOptimizeState *state)
{
    expr_ty arg = node->v.UnaryOp.operand;

    if (arg->kind != Constant_kind) {
        /* Fold not into comparison */
        if (node->v.UnaryOp.op == Not && arg->kind == Compare_kind &&
                asdl_seq_LEN(arg->v.Compare.ops) == 1) {
            /* Eq and NotEq are often implemented in terms of one another, so
               folding not (self == other) into self != other breaks implementation
               of !=. Detecting such cases doesn't seem worthwhile.
               Python uses </> for 'is subset'/'is superset' operations on sets.
               They don't satisfy not folding laws. */
            cmpop_ty op = asdl_seq_GET(arg->v.Compare.ops, 0);
            switch (op) {
            case Is:
                op = IsNot;
                break;
            case IsNot:
                op = Is;
                break;
            case In:
                op = NotIn;
                break;
            case NotIn:
                op = In;
                break;
            // The remaining comparison operators can't be safely inverted
            case Eq:
            case NotEq:
            case Lt:
            case LtE:
            case Gt:
            case GtE:
                op = 0; // The AST enums leave "0" free as an "unused" marker
                break;
            // No default case, so the compiler will emit a warning if new
            // comparison operators are added without being handled here
            }
            if (op) {
                asdl_seq_SET(arg->v.Compare.ops, 0, op);
                COPY_NODE(node, arg);
                return 1;
            }
        }
        return 1;
    }

    typedef PyObject *(*unary_op)(PyObject*);
    static const unary_op ops[] = {
        [Invert] = PyNumber_Invert,
        [Not] = unary_not,
        [UAdd] = PyNumber_Positive,
        [USub] = PyNumber_Negative,
    };
    PyObject *newval = ops[node->v.UnaryOp.op](arg->v.Constant.value);
    return make_const(node, newval, arena);
}

/* Check whether a collection doesn't containing too much items (including
   subcollections).  This protects from creating a constant that needs
   too much time for calculating a hash.
   "limit" is the maximal number of items.
   Returns the negative number if the total number of items exceeds the
   limit.  Otherwise returns the limit minus the total number of items.
*/

static Py_ssize_t
check_complexity(PyObject *obj, Py_ssize_t limit)
{
    if (PyTuple_Check(obj)) {
        Py_ssize_t i;
        limit -= PyTuple_GET_SIZE(obj);
        for (i = 0; limit >= 0 && i < PyTuple_GET_SIZE(obj); i++) {
            limit = check_complexity(PyTuple_GET_ITEM(obj, i), limit);
        }
        return limit;
    }
    else if (PyFrozenSet_Check(obj)) {
        Py_ssize_t i = 0;
        PyObject *item;
        Py_hash_t hash;
        limit -= PySet_GET_SIZE(obj);
        while (limit >= 0 && _PySet_NextEntry(obj, &i, &item, &hash)) {
            limit = check_complexity(item, limit);
        }
    }
    return limit;
}

#define MAX_INT_SIZE           128  /* bits */
#define MAX_COLLECTION_SIZE    256  /* items */
#define MAX_STR_SIZE          4096  /* characters */
#define MAX_TOTAL_ITEMS       1024  /* including nested collections */

static PyObject *
safe_multiply(PyObject *v, PyObject *w)
{
    if (PyLong_Check(v) && PyLong_Check(w) &&
        !_PyLong_IsZero((PyLongObject *)v) && !_PyLong_IsZero((PyLongObject *)w)
    ) {
        size_t vbits = _PyLong_NumBits(v);
        size_t wbits = _PyLong_NumBits(w);
        if (vbits == (size_t)-1 || wbits == (size_t)-1) {
            return NULL;
        }
        if (vbits + wbits > MAX_INT_SIZE) {
            return NULL;
        }
    }
    else if (PyLong_Check(v) && (PyTuple_Check(w) || PyFrozenSet_Check(w))) {
        Py_ssize_t size = PyTuple_Check(w) ? PyTuple_GET_SIZE(w) :
                                             PySet_GET_SIZE(w);
        if (size) {
            long n = PyLong_AsLong(v);
            if (n < 0 || n > MAX_COLLECTION_SIZE / size) {
                return NULL;
            }
            if (n && check_complexity(w, MAX_TOTAL_ITEMS / n) < 0) {
                return NULL;
            }
        }
    }
    else if (PyLong_Check(v) && (PyUnicode_Check(w) || PyBytes_Check(w))) {
        Py_ssize_t size = PyUnicode_Check(w) ? PyUnicode_GET_LENGTH(w) :
                                               PyBytes_GET_SIZE(w);
        if (size) {
            long n = PyLong_AsLong(v);
            if (n < 0 || n > MAX_STR_SIZE / size) {
                return NULL;
            }
        }
    }
    else if (PyLong_Check(w) &&
             (PyTuple_Check(v) || PyFrozenSet_Check(v) ||
              PyUnicode_Check(v) || PyBytes_Check(v)))
    {
        return safe_multiply(w, v);
    }

    return PyNumber_Multiply(v, w);
}

static PyObject *
safe_power(PyObject *v, PyObject *w)
{
    if (PyLong_Check(v) && PyLong_Check(w) &&
        !_PyLong_IsZero((PyLongObject *)v) && _PyLong_IsPositive((PyLongObject *)w)
    ) {
        size_t vbits = _PyLong_NumBits(v);
        size_t wbits = PyLong_AsSize_t(w);
        if (vbits == (size_t)-1 || wbits == (size_t)-1) {
            return NULL;
        }
        if (vbits > MAX_INT_SIZE / wbits) {
            return NULL;
        }
    }

    return PyNumber_Power(v, w, Py_None);
}

static PyObject *
safe_lshift(PyObject *v, PyObject *w)
{
    if (PyLong_Check(v) && PyLong_Check(w) &&
        !_PyLong_IsZero((PyLongObject *)v) && !_PyLong_IsZero((PyLongObject *)w)
    ) {
        size_t vbits = _PyLong_NumBits(v);
        size_t wbits = PyLong_AsSize_t(w);
        if (vbits == (size_t)-1 || wbits == (size_t)-1) {
            return NULL;
        }
        if (wbits > MAX_INT_SIZE || vbits > MAX_INT_SIZE - wbits) {
            return NULL;
        }
    }

    return PyNumber_Lshift(v, w);
}

static PyObject *
safe_mod(PyObject *v, PyObject *w)
{
    if (PyUnicode_Check(v) || PyBytes_Check(v)) {
        return NULL;
    }

    return PyNumber_Remainder(v, w);
}


static expr_ty
parse_literal(PyObject *fmt, Py_ssize_t *ppos, PyArena *arena)
{
    const void *data = PyUnicode_DATA(fmt);
    int kind = PyUnicode_KIND(fmt);
    Py_ssize_t size = PyUnicode_GET_LENGTH(fmt);
    Py_ssize_t start, pos;
    int has_percents = 0;
    start = pos = *ppos;
    while (pos < size) {
        if (PyUnicode_READ(kind, data, pos) != '%') {
            pos++;
        }
        else if (pos+1 < size && PyUnicode_READ(kind, data, pos+1) == '%') {
            has_percents = 1;
            pos += 2;
        }
        else {
            break;
        }
    }
    *ppos = pos;
    if (pos == start) {
        return NULL;
    }
    PyObject *str = PyUnicode_Substring(fmt, start, pos);
    /* str = str.replace('%%', '%') */
    if (str && has_percents) {
        _Py_DECLARE_STR(percent, "%");
        _Py_DECLARE_STR(dbl_percent, "%%");
        Py_SETREF(str, PyUnicode_Replace(str, &_Py_STR(dbl_percent),
                                         &_Py_STR(percent), -1));
    }
    if (!str) {
        return NULL;
    }

    if (_PyArena_AddPyObject(arena, str) < 0) {
        Py_DECREF(str);
        return NULL;
    }
    return _PyAST_Constant(str, NULL, -1, -1, -1, -1, arena);
}

#define MAXDIGITS 3

static int
simple_format_arg_parse(PyObject *fmt, Py_ssize_t *ppos,
                        int *spec, int *flags, int *width, int *prec)
{
    Py_ssize_t pos = *ppos, len = PyUnicode_GET_LENGTH(fmt);
    Py_UCS4 ch;

#define NEXTC do {                      \
    if (pos >= len) {                   \
        return 0;                       \
    }                                   \
    ch = PyUnicode_READ_CHAR(fmt, pos); \
    pos++;                              \
} while (0)

    *flags = 0;
    while (1) {
        NEXTC;
        switch (ch) {
            case '-': *flags |= F_LJUST; continue;
            case '+': *flags |= F_SIGN; continue;
            case ' ': *flags |= F_BLANK; continue;
            case '#': *flags |= F_ALT; continue;
            case '0': *flags |= F_ZERO; continue;
        }
        break;
    }
    if ('0' <= ch && ch <= '9') {
        *width = 0;
        int digits = 0;
        while ('0' <= ch && ch <= '9') {
            *width = *width * 10 + (ch - '0');
            NEXTC;
            if (++digits >= MAXDIGITS) {
                return 0;
            }
        }
    }

    if (ch == '.') {
        NEXTC;
        *prec = 0;
        if ('0' <= ch && ch <= '9') {
            int digits = 0;
            while ('0' <= ch && ch <= '9') {
                *prec = *prec * 10 + (ch - '0');
                NEXTC;
                if (++digits >= MAXDIGITS) {
                    return 0;
                }
            }
        }
    }
    *spec = ch;
    *ppos = pos;
    return 1;

#undef NEXTC
}

static expr_ty
parse_format(PyObject *fmt, Py_ssize_t *ppos, expr_ty arg, PyArena *arena)
{
    int spec, flags, width = -1, prec = -1;
    if (!simple_format_arg_parse(fmt, ppos, &spec, &flags, &width, &prec)) {
        // Unsupported format.
        return NULL;
    }
    if (spec == 's' || spec == 'r' || spec == 'a') {
        char buf[1 + MAXDIGITS + 1 + MAXDIGITS + 1], *p = buf;
        if (!(flags & F_LJUST) && width > 0) {
            *p++ = '>';
        }
        if (width >= 0) {
            p += snprintf(p, MAXDIGITS + 1, "%d", width);
        }
        if (prec >= 0) {
            p += snprintf(p, MAXDIGITS + 2, ".%d", prec);
        }
        expr_ty format_spec = NULL;
        if (p != buf) {
            PyObject *str = PyUnicode_FromString(buf);
            if (str == NULL) {
                return NULL;
            }
            if (_PyArena_AddPyObject(arena, str) < 0) {
                Py_DECREF(str);
                return NULL;
            }
            format_spec = _PyAST_Constant(str, NULL, -1, -1, -1, -1, arena);
            if (format_spec == NULL) {
                return NULL;
            }
        }
        return _PyAST_FormattedValue(arg, spec, format_spec,
                                     arg->lineno, arg->col_offset,
                                     arg->end_lineno, arg->end_col_offset,
                                     arena);
    }
    // Unsupported format.
    return NULL;
}

static int
optimize_format(expr_ty node, PyObject *fmt, asdl_expr_seq *elts, PyArena *arena)
{
    Py_ssize_t pos = 0;
    Py_ssize_t cnt = 0;
    asdl_expr_seq *seq = _Py_asdl_expr_seq_new(asdl_seq_LEN(elts) * 2 + 1, arena);
    if (!seq) {
        return 0;
    }
    seq->size = 0;

    while (1) {
        expr_ty lit = parse_literal(fmt, &pos, arena);
        if (lit) {
            asdl_seq_SET(seq, seq->size++, lit);
        }
        else if (PyErr_Occurred()) {
            return 0;
        }

        if (pos >= PyUnicode_GET_LENGTH(fmt)) {
            break;
        }
        if (cnt >= asdl_seq_LEN(elts)) {
            // More format units than items.
            return 1;
        }
        assert(PyUnicode_READ_CHAR(fmt, pos) == '%');
        pos++;
        expr_ty expr = parse_format(fmt, &pos, asdl_seq_GET(elts, cnt), arena);
        cnt++;
        if (!expr) {
            return !PyErr_Occurred();
        }
        asdl_seq_SET(seq, seq->size++, expr);
    }
    if (cnt < asdl_seq_LEN(elts)) {
        // More items than format units.
        return 1;
    }
    expr_ty res = _PyAST_JoinedStr(seq,
                                   node->lineno, node->col_offset,
                                   node->end_lineno, node->end_col_offset,
                                   arena);
    if (!res) {
        return 0;
    }
    COPY_NODE(node, res);
//     PySys_FormatStderr("format = %R\n", fmt);
    return 1;
}

static int
fold_binop(expr_ty node, PyArena *arena, _PyASTOptimizeState *state)
{
    expr_ty lhs, rhs;
    lhs = node->v.BinOp.left;
    rhs = node->v.BinOp.right;
    if (lhs->kind != Constant_kind) {
        return 1;
    }
    PyObject *lv = lhs->v.Constant.value;

    if (node->v.BinOp.op == Mod &&
        rhs->kind == Tuple_kind &&
        PyUnicode_Check(lv) &&
        !has_starred(rhs->v.Tuple.elts))
    {
        return optimize_format(node, lv, rhs->v.Tuple.elts, arena);
    }

    if (rhs->kind != Constant_kind) {
        return 1;
    }

    PyObject *rv = rhs->v.Constant.value;
    PyObject *newval = NULL;

    switch (node->v.BinOp.op) {
    case Add:
        newval = PyNumber_Add(lv, rv);
        break;
    case Sub:
        newval = PyNumber_Subtract(lv, rv);
        break;
    case Mult:
        newval = safe_multiply(lv, rv);
        break;
    case Div:
        newval = PyNumber_TrueDivide(lv, rv);
        break;
    case FloorDiv:
        newval = PyNumber_FloorDivide(lv, rv);
        break;
    case Mod:
        newval = safe_mod(lv, rv);
        break;
    case Pow:
        newval = safe_power(lv, rv);
        break;
    case LShift:
        newval = safe_lshift(lv, rv);
        break;
    case RShift:
        newval = PyNumber_Rshift(lv, rv);
        break;
    case BitOr:
        newval = PyNumber_Or(lv, rv);
        break;
    case BitXor:
        newval = PyNumber_Xor(lv, rv);
        break;
    case BitAnd:
        newval = PyNumber_And(lv, rv);
        break;
    // No builtin constants implement the following operators
    case MatMult:
        return 1;
    // No default case, so the compiler will emit a warning if new binary
    // operators are added without being handled here
    }

    return make_const(node, newval, arena);
}

static PyObject*
make_const_tuple(asdl_expr_seq *elts)
{
    for (int i = 0; i < asdl_seq_LEN(elts); i++) {
        expr_ty e = (expr_ty)asdl_seq_GET(elts, i);
        if (e->kind != Constant_kind) {
            return NULL;
        }
    }

    PyObject *newval = PyTuple_New(asdl_seq_LEN(elts));
    if (newval == NULL) {
        return NULL;
    }

    for (int i = 0; i < asdl_seq_LEN(elts); i++) {
        expr_ty e = (expr_ty)asdl_seq_GET(elts, i);
        PyObject *v = e->v.Constant.value;
        PyTuple_SET_ITEM(newval, i, Py_NewRef(v));
    }
    return newval;
}

static int
fold_tuple(expr_ty node, PyArena *arena, _PyASTOptimizeState *state)
{
    PyObject *newval;

    if (node->v.Tuple.ctx != Load)
        return 1;

    newval = make_const_tuple(node->v.Tuple.elts);
    return make_const(node, newval, arena);
}

static int
fold_subscr(expr_ty node, PyArena *arena, _PyASTOptimizeState *state)
{
    PyObject *newval;
    expr_ty arg, idx;

    arg = node->v.Subscript.value;
    idx = node->v.Subscript.slice;
    if (node->v.Subscript.ctx != Load ||
            arg->kind != Constant_kind ||
            idx->kind != Constant_kind)
    {
        return 1;
    }

    newval = PyObject_GetItem(arg->v.Constant.value, idx->v.Constant.value);
    return make_const(node, newval, arena);
}

/* Change literal list or set of constants into constant
   tuple or frozenset respectively.  Change literal list of
   non-constants into tuple.
   Used for right operand of "in" and "not in" tests and for iterable
   in "for" loop and comprehensions.
*/
static int
fold_iter(expr_ty arg, PyArena *arena, _PyASTOptimizeState *state)
{
    PyObject *newval;
    if (arg->kind == List_kind) {
        /* First change a list into tuple. */
        asdl_expr_seq *elts = arg->v.List.elts;
        if (has_starred(elts)) {
            return 1;
        }
        expr_context_ty ctx = arg->v.List.ctx;
        arg->kind = Tuple_kind;
        arg->v.Tuple.elts = elts;
        arg->v.Tuple.ctx = ctx;
        /* Try to create a constant tuple. */
        newval = make_const_tuple(elts);
    }
    else if (arg->kind == Set_kind) {
        newval = make_const_tuple(arg->v.Set.elts);
        if (newval) {
            Py_SETREF(newval, PyFrozenSet_New(newval));
        }
    }
    else {
        return 1;
    }
    return make_const(arg, newval, arena);
}

static int
fold_compare(expr_ty node, PyArena *arena, _PyASTOptimizeState *state)
{
    asdl_int_seq *ops;
    asdl_expr_seq *args;
    Py_ssize_t i;

    ops = node->v.Compare.ops;
    args = node->v.Compare.comparators;
    /* Change literal list or set in 'in' or 'not in' into
       tuple or frozenset respectively. */
    i = asdl_seq_LEN(ops) - 1;
    int op = asdl_seq_GET(ops, i);
    if (op == In || op == NotIn) {
        if (!fold_iter((expr_ty)asdl_seq_GET(args, i), arena, state)) {
            return 0;
        }
    }
    return 1;
}

static int astfold_mod(mod_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_arguments(arguments_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_comprehension(comprehension_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_keyword(keyword_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_arg(arg_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_withitem(withitem_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_excepthandler(excepthandler_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_match_case(match_case_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_pattern(pattern_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_type_param(type_param_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);

#define CALL(FUNC, TYPE, ARG) \
    if (!FUNC((ARG), ctx_, state)) \
        return 0;

#define CALL_OPT(FUNC, TYPE, ARG) \
    if ((ARG) != NULL && !FUNC((ARG), ctx_, state)) \
        return 0;

#define CALL_SEQ(FUNC, TYPE, ARG) { \
    int i; \
    asdl_ ## TYPE ## _seq *seq = (ARG); /* avoid variable capture */ \
    for (i = 0; i < asdl_seq_LEN(seq); i++) { \
        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
        if (elt != NULL && !FUNC(elt, ctx_, state)) \
            return 0; \
    } \
}


static int
astfold_body(asdl_stmt_seq *stmts, PyArena *ctx_, _PyASTOptimizeState *state)
{
    int docstring = _PyAST_GetDocString(stmts) != NULL;
    CALL_SEQ(astfold_stmt, stmt, stmts);
    if (!docstring && _PyAST_GetDocString(stmts) != NULL) {
        stmt_ty st = (stmt_ty)asdl_seq_GET(stmts, 0);
        asdl_expr_seq *values = _Py_asdl_expr_seq_new(1, ctx_);
        if (!values) {
            return 0;
        }
        asdl_seq_SET(values, 0, st->v.Expr.value);
        expr_ty expr = _PyAST_JoinedStr(values, st->lineno, st->col_offset,
                                        st->end_lineno, st->end_col_offset,
                                        ctx_);
        if (!expr) {
            return 0;
        }
        st->v.Expr.value = expr;
    }
    return 1;
}

static int
astfold_mod(mod_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    switch (node_->kind) {
    case Module_kind:
        CALL(astfold_body, asdl_seq, node_->v.Module.body);
        break;
    case Interactive_kind:
        CALL_SEQ(astfold_stmt, stmt, node_->v.Interactive.body);
        break;
    case Expression_kind:
        CALL(astfold_expr, expr_ty, node_->v.Expression.body);
        break;
    // The following top level nodes don't participate in constant folding
    case FunctionType_kind:
        break;
    // No default case, so the compiler will emit a warning if new top level
    // compilation nodes are added without being handled here
    }
    return 1;
}

static int
astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    if (++state->recursion_depth > state->recursion_limit) {
        PyErr_SetString(PyExc_RecursionError,
                        "maximum recursion depth exceeded during compilation");
        return 0;
    }
    switch (node_->kind) {
    case BoolOp_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.BoolOp.values);
        break;
    case BinOp_kind:
        CALL(astfold_expr, expr_ty, node_->v.BinOp.left);
        CALL(astfold_expr, expr_ty, node_->v.BinOp.right);
        CALL(fold_binop, expr_ty, node_);
        break;
    case UnaryOp_kind:
        CALL(astfold_expr, expr_ty, node_->v.UnaryOp.operand);
        CALL(fold_unaryop, expr_ty, node_);
        break;
    case Lambda_kind:
        CALL(astfold_arguments, arguments_ty, node_->v.Lambda.args);
        CALL(astfold_expr, expr_ty, node_->v.Lambda.body);
        break;
    case IfExp_kind:
        CALL(astfold_expr, expr_ty, node_->v.IfExp.test);
        CALL(astfold_expr, expr_ty, node_->v.IfExp.body);
        CALL(astfold_expr, expr_ty, node_->v.IfExp.orelse);
        break;
    case Dict_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.Dict.keys);
        CALL_SEQ(astfold_expr, expr, node_->v.Dict.values);
        break;
    case Set_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.Set.elts);
        break;
    case ListComp_kind:
        CALL(astfold_expr, expr_ty, node_->v.ListComp.elt);
        CALL_SEQ(astfold_comprehension, comprehension, node_->v.ListComp.generators);
        break;
    case SetComp_kind:
        CALL(astfold_expr, expr_ty, node_->v.SetComp.elt);
        CALL_SEQ(astfold_comprehension, comprehension, node_->v.SetComp.generators);
        break;
    case DictComp_kind:
        CALL(astfold_expr, expr_ty, node_->v.DictComp.key);
        CALL(astfold_expr, expr_ty, node_->v.DictComp.value);
        CALL_SEQ(astfold_comprehension, comprehension, node_->v.DictComp.generators);
        break;
    case GeneratorExp_kind:
        CALL(astfold_expr, expr_ty, node_->v.GeneratorExp.elt);
        CALL_SEQ(astfold_comprehension, comprehension, node_->v.GeneratorExp.generators);
        break;
    case Await_kind:
        CALL(astfold_expr, expr_ty, node_->v.Await.value);
        break;
    case Yield_kind:
        CALL_OPT(astfold_expr, expr_ty, node_->v.Yield.value);
        break;
    case YieldFrom_kind:
        CALL(astfold_expr, expr_ty, node_->v.YieldFrom.value);
        break;
    case Compare_kind:
        CALL(astfold_expr, expr_ty, node_->v.Compare.left);
        CALL_SEQ(astfold_expr, expr, node_->v.Compare.comparators);
        CALL(fold_compare, expr_ty, node_);
        break;
    case Call_kind:
        CALL(astfold_expr, expr_ty, node_->v.Call.func);
        CALL_SEQ(astfold_expr, expr, node_->v.Call.args);
        CALL_SEQ(astfold_keyword, keyword, node_->v.Call.keywords);
        break;
    case FormattedValue_kind:
        CALL(astfold_expr, expr_ty, node_->v.FormattedValue.value);
        CALL_OPT(astfold_expr, expr_ty, node_->v.FormattedValue.format_spec);
        break;
    case JoinedStr_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.JoinedStr.values);
        break;
    case Attribute_kind:
        CALL(astfold_expr, expr_ty, node_->v.Attribute.value);
        break;
    case Subscript_kind:
        CALL(astfold_expr, expr_ty, node_->v.Subscript.value);
        CALL(astfold_expr, expr_ty, node_->v.Subscript.slice);
        CALL(fold_subscr, expr_ty, node_);
        break;
    case Starred_kind:
        CALL(astfold_expr, expr_ty, node_->v.Starred.value);
        break;
    case Slice_kind:
        CALL_OPT(astfold_expr, expr_ty, node_->v.Slice.lower);
        CALL_OPT(astfold_expr, expr_ty, node_->v.Slice.upper);
        CALL_OPT(astfold_expr, expr_ty, node_->v.Slice.step);
        break;
    case List_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.List.elts);
        break;
    case Tuple_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.Tuple.elts);
        CALL(fold_tuple, expr_ty, node_);
        break;
    case Name_kind:
        if (node_->v.Name.ctx == Load &&
                _PyUnicode_EqualToASCIIString(node_->v.Name.id, "__debug__")) {
            state->recursion_depth--;
            return make_const(node_, PyBool_FromLong(!state->optimize), ctx_);
        }
        break;
    case NamedExpr_kind:
        CALL(astfold_expr, expr_ty, node_->v.NamedExpr.value);
        break;
    case Constant_kind:
        // Already a constant, nothing further to do
        break;
    // No default case, so the compiler will emit a warning if new expression
    // kinds are added without being handled here
    }
    state->recursion_depth--;
    return 1;
}

static int
astfold_keyword(keyword_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    CALL(astfold_expr, expr_ty, node_->value);
    return 1;
}

static int
astfold_comprehension(comprehension_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    CALL(astfold_expr, expr_ty, node_->target);
    CALL(astfold_expr, expr_ty, node_->iter);
    CALL_SEQ(astfold_expr, expr, node_->ifs);

    CALL(fold_iter, expr_ty, node_->iter);
    return 1;
}

static int
astfold_arguments(arguments_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    CALL_SEQ(astfold_arg, arg, node_->posonlyargs);
    CALL_SEQ(astfold_arg, arg, node_->args);
    CALL_OPT(astfold_arg, arg_ty, node_->vararg);
    CALL_SEQ(astfold_arg, arg, node_->kwonlyargs);
    CALL_SEQ(astfold_expr, expr, node_->kw_defaults);
    CALL_OPT(astfold_arg, arg_ty, node_->kwarg);
    CALL_SEQ(astfold_expr, expr, node_->defaults);
    return 1;
}

static int
astfold_arg(arg_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    if (!(state->ff_features & CO_FUTURE_ANNOTATIONS)) {
        CALL_OPT(astfold_expr, expr_ty, node_->annotation);
    }
    return 1;
}

static int
astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    if (++state->recursion_depth > state->recursion_limit) {
        PyErr_SetString(PyExc_RecursionError,
                        "maximum recursion depth exceeded during compilation");
        return 0;
    }
    switch (node_->kind) {
    case FunctionDef_kind:
        CALL_SEQ(astfold_type_param, type_param, node_->v.FunctionDef.type_params);
        CALL(astfold_arguments, arguments_ty, node_->v.FunctionDef.args);
        CALL(astfold_body, asdl_seq, node_->v.FunctionDef.body);
        CALL_SEQ(astfold_expr, expr, node_->v.FunctionDef.decorator_list);
        if (!(state->ff_features & CO_FUTURE_ANNOTATIONS)) {
            CALL_OPT(astfold_expr, expr_ty, node_->v.FunctionDef.returns);
        }
        break;
    case AsyncFunctionDef_kind:
        CALL_SEQ(astfold_type_param, type_param, node_->v.AsyncFunctionDef.type_params);
        CALL(astfold_arguments, arguments_ty, node_->v.AsyncFunctionDef.args);
        CALL(astfold_body, asdl_seq, node_->v.AsyncFunctionDef.body);
        CALL_SEQ(astfold_expr, expr, node_->v.AsyncFunctionDef.decorator_list);
        if (!(state->ff_features & CO_FUTURE_ANNOTATIONS)) {
            CALL_OPT(astfold_expr, expr_ty, node_->v.AsyncFunctionDef.returns);
        }
        break;
    case ClassDef_kind:
        CALL_SEQ(astfold_type_param, type_param, node_->v.ClassDef.type_params);
        CALL_SEQ(astfold_expr, expr, node_->v.ClassDef.bases);
        CALL_SEQ(astfold_keyword, keyword, node_->v.ClassDef.keywords);
        CALL(astfold_body, asdl_seq, node_->v.ClassDef.body);
        CALL_SEQ(astfold_expr, expr, node_->v.ClassDef.decorator_list);
        break;
    case Return_kind:
        CALL_OPT(astfold_expr, expr_ty, node_->v.Return.value);
        break;
    case Delete_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.Delete.targets);
        break;
    case Assign_kind:
        CALL_SEQ(astfold_expr, expr, node_->v.Assign.targets);
        CALL(astfold_expr, expr_ty, node_->v.Assign.value);
        break;
    case AugAssign_kind:
        CALL(astfold_expr, expr_ty, node_->v.AugAssign.target);
        CALL(astfold_expr, expr_ty, node_->v.AugAssign.value);
        break;
    case AnnAssign_kind:
        CALL(astfold_expr, expr_ty, node_->v.AnnAssign.target);
        if (!(state->ff_features & CO_FUTURE_ANNOTATIONS)) {
            CALL(astfold_expr, expr_ty, node_->v.AnnAssign.annotation);
        }
        CALL_OPT(astfold_expr, expr_ty, node_->v.AnnAssign.value);
        break;
    case TypeAlias_kind:
        CALL(astfold_expr, expr_ty, node_->v.TypeAlias.name);
        CALL_SEQ(astfold_type_param, type_param, node_->v.TypeAlias.type_params);
        CALL(astfold_expr, expr_ty, node_->v.TypeAlias.value);
        break;
    case For_kind:
        CALL(astfold_expr, expr_ty, node_->v.For.target);
        CALL(astfold_expr, expr_ty, node_->v.For.iter);
        CALL_SEQ(astfold_stmt, stmt, node_->v.For.body);
        CALL_SEQ(astfold_stmt, stmt, node_->v.For.orelse);

        CALL(fold_iter, expr_ty, node_->v.For.iter);
        break;
    case AsyncFor_kind:
        CALL(astfold_expr, expr_ty, node_->v.AsyncFor.target);
        CALL(astfold_expr, expr_ty, node_->v.AsyncFor.iter);
        CALL_SEQ(astfold_stmt, stmt, node_->v.AsyncFor.body);
        CALL_SEQ(astfold_stmt, stmt, node_->v.AsyncFor.orelse);
        break;
    case While_kind:
        CALL(astfold_expr, expr_ty, node_->v.While.test);
        CALL_SEQ(astfold_stmt, stmt, node_->v.While.body);
        CALL_SEQ(astfold_stmt, stmt, node_->v.While.orelse);
        break;
    case If_kind:
        CALL(astfold_expr, expr_ty, node_->v.If.test);
        CALL_SEQ(astfold_stmt, stmt, node_->v.If.body);
        CALL_SEQ(astfold_stmt, stmt, node_->v.If.orelse);
        break;
    case With_kind:
        CALL_SEQ(astfold_withitem, withitem, node_->v.With.items);
        CALL_SEQ(astfold_stmt, stmt, node_->v.With.body);
        break;
    case AsyncWith_kind:
        CALL_SEQ(astfold_withitem, withitem, node_->v.AsyncWith.items);
        CALL_SEQ(astfold_stmt, stmt, node_->v.AsyncWith.body);
        break;
    case Raise_kind:
        CALL_OPT(astfold_expr, expr_ty, node_->v.Raise.exc);
        CALL_OPT(astfold_expr, expr_ty, node_->v.Raise.cause);
        break;
    case Try_kind:
        CALL_SEQ(astfold_stmt, stmt, node_->v.Try.body);
        CALL_SEQ(astfold_excepthandler, excepthandler, node_->v.Try.handlers);
        CALL_SEQ(astfold_stmt, stmt, node_->v.Try.orelse);
        CALL_SEQ(astfold_stmt, stmt, node_->v.Try.finalbody);
        break;
    case TryStar_kind:
        CALL_SEQ(astfold_stmt, stmt, node_->v.TryStar.body);
        CALL_SEQ(astfold_excepthandler, excepthandler, node_->v.TryStar.handlers);
        CALL_SEQ(astfold_stmt, stmt, node_->v.TryStar.orelse);
        CALL_SEQ(astfold_stmt, stmt, node_->v.TryStar.finalbody);
        break;
    case Assert_kind:
        CALL(astfold_expr, expr_ty, node_->v.Assert.test);
        CALL_OPT(astfold_expr, expr_ty, node_->v.Assert.msg);
        break;
    case Expr_kind:
        CALL(astfold_expr, expr_ty, node_->v.Expr.value);
        break;
    case Match_kind:
        CALL(astfold_expr, expr_ty, node_->v.Match.subject);
        CALL_SEQ(astfold_match_case, match_case, node_->v.Match.cases);
        break;
    // The following statements don't contain any subexpressions to be folded
    case Import_kind:
    case ImportFrom_kind:
    case Global_kind:
    case Nonlocal_kind:
    case Pass_kind:
    case Break_kind:
    case Continue_kind:
        break;
    // No default case, so the compiler will emit a warning if new statement
    // kinds are added without being handled here
    }
    state->recursion_depth--;
    return 1;
}

static int
astfold_excepthandler(excepthandler_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    switch (node_->kind) {
    case ExceptHandler_kind:
        CALL_OPT(astfold_expr, expr_ty, node_->v.ExceptHandler.type);
        CALL_SEQ(astfold_stmt, stmt, node_->v.ExceptHandler.body);
        break;
    // No default case, so the compiler will emit a warning if new handler
    // kinds are added without being handled here
    }
    return 1;
}

static int
astfold_withitem(withitem_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    CALL(astfold_expr, expr_ty, node_->context_expr);
    CALL_OPT(astfold_expr, expr_ty, node_->optional_vars);
    return 1;
}

static int
astfold_pattern(pattern_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    // Currently, this is really only used to form complex/negative numeric
    // constants in MatchValue and MatchMapping nodes
    // We still recurse into all subexpressions and subpatterns anyway
    if (++state->recursion_depth > state->recursion_limit) {
        PyErr_SetString(PyExc_RecursionError,
                        "maximum recursion depth exceeded during compilation");
        return 0;
    }
    switch (node_->kind) {
        case MatchValue_kind:
            CALL(astfold_expr, expr_ty, node_->v.MatchValue.value);
            break;
        case MatchSingleton_kind:
            break;
        case MatchSequence_kind:
            CALL_SEQ(astfold_pattern, pattern, node_->v.MatchSequence.patterns);
            break;
        case MatchMapping_kind:
            CALL_SEQ(astfold_expr, expr, node_->v.MatchMapping.keys);
            CALL_SEQ(astfold_pattern, pattern, node_->v.MatchMapping.patterns);
            break;
        case MatchClass_kind:
            CALL(astfold_expr, expr_ty, node_->v.MatchClass.cls);
            CALL_SEQ(astfold_pattern, pattern, node_->v.MatchClass.patterns);
            CALL_SEQ(astfold_pattern, pattern, node_->v.MatchClass.kwd_patterns);
            break;
        case MatchStar_kind:
            break;
        case MatchAs_kind:
            if (node_->v.MatchAs.pattern) {
                CALL(astfold_pattern, pattern_ty, node_->v.MatchAs.pattern);
            }
            break;
        case MatchOr_kind:
            CALL_SEQ(astfold_pattern, pattern, node_->v.MatchOr.patterns);
            break;
    // No default case, so the compiler will emit a warning if new pattern
    // kinds are added without being handled here
    }
    state->recursion_depth--;
    return 1;
}

static int
astfold_match_case(match_case_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    CALL(astfold_pattern, expr_ty, node_->pattern);
    CALL_OPT(astfold_expr, expr_ty, node_->guard);
    CALL_SEQ(astfold_stmt, stmt, node_->body);
    return 1;
}

static int
astfold_type_param(type_param_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
    switch (node_->kind) {
        case TypeVar_kind:
            CALL_OPT(astfold_expr, expr_ty, node_->v.TypeVar.bound);
            break;
        case ParamSpec_kind:
            break;
        case TypeVarTuple_kind:
            break;
    }
    return 1;
}

#undef CALL
#undef CALL_OPT
#undef CALL_SEQ

/* See comments in symtable.c. */
#define COMPILER_STACK_FRAME_SCALE 3

int
_PyAST_Optimize(mod_ty mod, PyArena *arena, int optimize, int ff_features)
{
    PyThreadState *tstate;
    int starting_recursion_depth;

    _PyASTOptimizeState state;
    state.optimize = optimize;
    state.ff_features = ff_features;

    /* Setup recursion depth check counters */
    tstate = _PyThreadState_GET();
    if (!tstate) {
        return 0;
    }
    /* Be careful here to prevent overflow. */
    int recursion_depth = C_RECURSION_LIMIT - tstate->c_recursion_remaining;
    starting_recursion_depth = recursion_depth * COMPILER_STACK_FRAME_SCALE;
    state.recursion_depth = starting_recursion_depth;
    state.recursion_limit = C_RECURSION_LIMIT * COMPILER_STACK_FRAME_SCALE;

    int ret = astfold_mod(mod, arena, &state);
    assert(ret || PyErr_Occurred());

    /* Check that the recursion depth counting balanced correctly */
    if (ret && state.recursion_depth != starting_recursion_depth) {
        PyErr_Format(PyExc_SystemError,
            "AST optimizer recursion depth mismatch (before=%d, after=%d)",
            starting_recursion_depth, state.recursion_depth);
        return 0;
    }

    return ret;
}


================================================
FILE: Ast_Unparse.c
================================================
#include "Python.h"
#include "pycore_ast.h"           // expr_ty
#include "pycore_pystate.h"       // _PyInterpreterState_GET()
#include "pycore_runtime.h"       // _Py_ID()
#include <float.h>                // DBL_MAX_10_EXP
#include <stdbool.h>

/* This limited unparser is used to convert annotations back to strings
 * during compilation rather than being a full AST unparser.
 * See ast.unparse for a full unparser (written in Python)
 */

_Py_DECLARE_STR(open_br, "{");
_Py_DECLARE_STR(dbl_open_br, "{{");
_Py_DECLARE_STR(close_br, "}");
_Py_DECLARE_STR(dbl_close_br, "}}");

/* We would statically initialize this if doing so were simple enough. */
#define _str_replace_inf(interp) \
    _Py_INTERP_CACHED_OBJECT(interp, str_replace_inf)

/* Forward declarations for recursion via helper functions. */
static PyObject *
expr_as_unicode(expr_ty e, int level);
static int
append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level);
static int
append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec);
static int
append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e);
static int
append_ast_slice(_PyUnicodeWriter *writer, expr_ty e);

static int
append_charp(_PyUnicodeWriter *writer, const char *charp)
{
    return _PyUnicodeWriter_WriteASCIIString(writer, charp, -1);
}

#define APPEND_STR_FINISH(str)  do { \
        return append_charp(writer, (str)); \
    } while (0)

#define APPEND_STR(str)  do { \
        if (-1 == append_charp(writer, (str))) { \
            return -1; \
        } \
    } while (0)

#define APPEND_STR_IF(cond, str)  do { \
        if ((cond) && -1 == append_charp(writer, (str))) { \
            return -1; \
        } \
    } while (0)

#define APPEND_STR_IF_NOT_FIRST(str)  do { \
        APPEND_STR_IF(!first, (str)); \
        first = false; \
    } while (0)

#define APPEND_EXPR(expr, pr)  do { \
        if (-1 == append_ast_expr(writer, (expr), (pr))) { \
            return -1; \
        } \
    } while (0)

#define APPEND(type, value)  do { \
        if (-1 == append_ast_ ## type(writer, (value))) { \
            return -1; \
        } \
    } while (0)

static int
append_repr(_PyUnicodeWriter *writer, PyObject *obj)
{
    PyObject *repr = PyObject_Repr(obj);

    if (!repr) {
        return -1;
    }

    if ((PyFloat_CheckExact(obj) && Py_IS_INFINITY(PyFloat_AS_DOUBLE(obj))) ||
       PyComplex_CheckExact(obj))
    {
        PyInterpreterState *interp = _PyInterpreterState_GET();
        PyObject *new_repr = PyUnicode_Replace(
            repr,
            &_Py_ID(inf),
            _str_replace_inf(interp),
            -1
        );
        Py_DECREF(repr);
        if (!new_repr) {
            return -1;
        }
        repr = new_repr;
    }
    int ret = _PyUnicodeWriter_WriteStr(writer, repr);
    Py_DECREF(repr);
    return ret;
}

/* Priority levels */

enum {
    PR_TUPLE,
    PR_TEST,            /* 'if'-'else', 'lambda' */
    PR_OR,              /* 'or' */
    PR_AND,             /* 'and' */
    PR_NOT,             /* 'not' */
    PR_CMP,             /* '<', '>', '==', '>=', '<=', '!=',
                           'in', 'not in', 'is', 'is not' */
    PR_EXPR,
    PR_BOR = PR_EXPR,   /* '|' */
    PR_BXOR,            /* '^' */
    PR_BAND,            /* '&' */
    PR_SHIFT,           /* '<<', '>>' */
    PR_ARITH,           /* '+', '-' */
    PR_TERM,            /* '*', '@', '/', '%', '//' */
    PR_FACTOR,          /* unary '+', '-', '~' */
    PR_POWER,           /* '**' */
    PR_AWAIT,           /* 'await' */
    PR_ATOM,
};

static int
append_ast_boolop(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    Py_ssize_t i, value_count;
    asdl_expr_seq *values;
    const char *op = (e->v.BoolOp.op == And) ? " and " : " or ";
    int pr = (e->v.BoolOp.op == And) ? PR_AND : PR_OR;

    APPEND_STR_IF(level > pr, "(");

    values = e->v.BoolOp.values;
    value_count = asdl_seq_LEN(values);

    for (i = 0; i < value_count; ++i) {
        APPEND_STR_IF(i > 0, op);
        APPEND_EXPR((expr_ty)asdl_seq_GET(values, i), pr + 1);
    }

    APPEND_STR_IF(level > pr, ")");
    return 0;
}

static int
append_ast_binop(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    const char *op;
    int pr;
    bool rassoc = false;  /* is right-associative? */

    switch (e->v.BinOp.op) {
    case Add: op = " + "; pr = PR_ARITH; break;
    case Sub: op = " - "; pr = PR_ARITH; break;
    case Mult: op = " * "; pr = PR_TERM; break;
    case MatMult: op = " @ "; pr = PR_TERM; break;
    case Div: op = " / "; pr = PR_TERM; break;
    case Mod: op = " % "; pr = PR_TERM; break;
    case LShift: op = " << "; pr = PR_SHIFT; break;
    case RShift: op = " >> "; pr = PR_SHIFT; break;
    case BitOr: op = " | "; pr = PR_BOR; break;
    case BitXor: op = " ^ "; pr = PR_BXOR; break;
    case BitAnd: op = " & "; pr = PR_BAND; break;
    case FloorDiv: op = " // "; pr = PR_TERM; break;
    case Pow: op = " ** "; pr = PR_POWER; rassoc = true; break;
    default:
        PyErr_SetString(PyExc_SystemError,
                        "unknown binary operator");
        return -1;
    }

    APPEND_STR_IF(level > pr, "(");
    APPEND_EXPR(e->v.BinOp.left, pr + rassoc);
    APPEND_STR(op);
    APPEND_EXPR(e->v.BinOp.right, pr + !rassoc);
    APPEND_STR_IF(level > pr, ")");
    return 0;
}

static int
append_ast_unaryop(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    const char *op;
    int pr;

    switch (e->v.UnaryOp.op) {
    case Invert: op = "~"; pr = PR_FACTOR; break;
    case Not: op = "not "; pr = PR_NOT; break;
    case UAdd: op = "+"; pr = PR_FACTOR; break;
    case USub: op = "-"; pr = PR_FACTOR; break;
    default:
        PyErr_SetString(PyExc_SystemError,
                        "unknown unary operator");
        return -1;
    }

    APPEND_STR_IF(level > pr, "(");
    APPEND_STR(op);
    APPEND_EXPR(e->v.UnaryOp.operand, pr);
    APPEND_STR_IF(level > pr, ")");
    return 0;
}

static int
append_ast_arg(_PyUnicodeWriter *writer, arg_ty arg)
{
    if (-1 == _PyUnicodeWriter_WriteStr(writer, arg->arg)) {
        return -1;
    }
    if (arg->annotation) {
        APPEND_STR(": ");
        APPEND_EXPR(arg->annotation, PR_TEST);
    }
    return 0;
}

static int
append_ast_args(_PyUnicodeWriter *writer, arguments_ty args)
{
    bool first;
    Py_ssize_t i, di, arg_count, posonlyarg_count, default_count;

    first = true;

    /* positional-only and positional arguments with defaults */
    posonlyarg_count = asdl_seq_LEN(args->posonlyargs);
    arg_count = asdl_seq_LEN(args->args);
    default_count = asdl_seq_LEN(args->defaults);
    for (i = 0; i < posonlyarg_count + arg_count; i++) {
        APPEND_STR_IF_NOT_FIRST(", ");
        if (i < posonlyarg_count){
            APPEND(arg, (arg_ty)asdl_seq_GET(args->posonlyargs, i));
        } else {
            APPEND(arg, (arg_ty)asdl_seq_GET(args->args, i-posonlyarg_count));
        }

        di = i - posonlyarg_count - arg_count + default_count;
        if (di >= 0) {
            APPEND_STR("=");
            APPEND_EXPR((expr_ty)asdl_seq_GET(args->defaults, di), PR_TEST);
        }
        if (posonlyarg_count && i + 1 == posonlyarg_count) {
            APPEND_STR(", /");
        }
    }

    /* vararg, or bare '*' if no varargs but keyword-only arguments present */
    if (args->vararg || asdl_seq_LEN(args->kwonlyargs)) {
        APPEND_STR_IF_NOT_FIRST(", ");
        APPEND_STR("*");
        if (args->vararg) {
            APPEND(arg, args->vararg);
        }
    }

    /* keyword-only arguments */
    arg_count = asdl_seq_LEN(args->kwonlyargs);
    default_count = asdl_seq_LEN(args->kw_defaults);
    for (i = 0; i < arg_count; i++) {
        APPEND_STR_IF_NOT_FIRST(", ");
        APPEND(arg, (arg_ty)asdl_seq_GET(args->kwonlyargs, i));

        di = i - arg_count + default_count;
        if (di >= 0) {
            expr_ty default_ = (expr_ty)asdl_seq_GET(args->kw_defaults, di);
            if (default_) {
                APPEND_STR("=");
                APPEND_EXPR(default_, PR_TEST);
            }
        }
    }

    /* **kwargs */
    if (args->kwarg) {
        APPEND_STR_IF_NOT_FIRST(", ");
        APPEND_STR("**");
        APPEND(arg, args->kwarg);
    }

    return 0;
}

static int
append_ast_lambda(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    APPEND_STR_IF(level > PR_TEST, "(");
    Py_ssize_t n_positional = (asdl_seq_LEN(e->v.Lambda.args->args) +
                               asdl_seq_LEN(e->v.Lambda.args->posonlyargs));
    APPEND_STR(n_positional ? "lambda " : "lambda");
    APPEND(args, e->v.Lambda.args);
    APPEND_STR(": ");
    APPEND_EXPR(e->v.Lambda.body, PR_TEST);
    APPEND_STR_IF(level > PR_TEST, ")");
    return 0;
}

static int
append_ast_ifexp(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    APPEND_STR_IF(level > PR_TEST, "(");
    APPEND_EXPR(e->v.IfExp.body, PR_TEST + 1);
    APPEND_STR(" if ");
    APPEND_EXPR(e->v.IfExp.test, PR_TEST + 1);
    APPEND_STR(" else ");
    APPEND_EXPR(e->v.IfExp.orelse, PR_TEST);
    APPEND_STR_IF(level > PR_TEST, ")");
    return 0;
}

static int
append_ast_dict(_PyUnicodeWriter *writer, expr_ty e)
{
    Py_ssize_t i, value_count;
    expr_ty key_node;

    APPEND_STR("{");
    value_count = asdl_seq_LEN(e->v.Dict.values);

    for (i = 0; i < value_count; i++) {
        APPEND_STR_IF(i > 0, ", ");
        key_node = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i);
        if (key_node != NULL) {
            APPEND_EXPR(key_node, PR_TEST);
            APPEND_STR(": ");
            APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_TEST);
        }
        else {
            APPEND_STR("**");
            APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_EXPR);
        }
    }

    APPEND_STR_FINISH("}");
}

static int
append_ast_set(_PyUnicodeWriter *writer, expr_ty e)
{
    Py_ssize_t i, elem_count;

    APPEND_STR("{");
    elem_count = asdl_seq_LEN(e->v.Set.elts);
    for (i = 0; i < elem_count; i++) {
        APPEND_STR_IF(i > 0, ", ");
        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Set.elts, i), PR_TEST);
    }

    APPEND_STR_FINISH("}");
}

static int
append_ast_list(_PyUnicodeWriter *writer, expr_ty e)
{
    Py_ssize_t i, elem_count;

    APPEND_STR("[");
    elem_count = asdl_seq_LEN(e->v.List.elts);
    for (i = 0; i < elem_count; i++) {
        APPEND_STR_IF(i > 0, ", ");
        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.List.elts, i), PR_TEST);
    }

    APPEND_STR_FINISH("]");
}

static int
append_ast_tuple(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    Py_ssize_t i, elem_count;

    elem_count = asdl_seq_LEN(e->v.Tuple.elts);

    if (elem_count == 0) {
        APPEND_STR_FINISH("()");
    }

    APPEND_STR_IF(level > PR_TUPLE, "(");

    for (i = 0; i < elem_count; i++) {
        APPEND_STR_IF(i > 0, ", ");
        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Tuple.elts, i), PR_TEST);
    }

    APPEND_STR_IF(elem_count == 1, ",");
    APPEND_STR_IF(level > PR_TUPLE, ")");
    return 0;
}

static int
append_ast_comprehension(_PyUnicodeWriter *writer, comprehension_ty gen)
{
    Py_ssize_t i, if_count;

    APPEND_STR(gen->is_async ? " async for " : " for ");
    APPEND_EXPR(gen->target, PR_TUPLE);
    APPEND_STR(" in ");
    APPEND_EXPR(gen->iter, PR_TEST + 1);

    if_count = asdl_seq_LEN(gen->ifs);
    for (i = 0; i < if_count; i++) {
        APPEND_STR(" if ");
        APPEND_EXPR((expr_ty)asdl_seq_GET(gen->ifs, i), PR_TEST + 1);
    }
    return 0;
}

static int
append_ast_comprehensions(_PyUnicodeWriter *writer, asdl_comprehension_seq *comprehensions)
{
    Py_ssize_t i, gen_count;
    gen_count = asdl_seq_LEN(comprehensions);

    for (i = 0; i < gen_count; i++) {
        APPEND(comprehension, (comprehension_ty)asdl_seq_GET(comprehensions, i));
    }

    return 0;
}

static int
append_ast_genexp(_PyUnicodeWriter *writer, expr_ty e)
{
    APPEND_STR("(");
    APPEND_EXPR(e->v.GeneratorExp.elt, PR_TEST);
    APPEND(comprehensions, e->v.GeneratorExp.generators);
    APPEND_STR_FINISH(")");
}

static int
append_ast_listcomp(_PyUnicodeWriter *writer, expr_ty e)
{
    APPEND_STR("[");
    APPEND_EXPR(e->v.ListComp.elt, PR_TEST);
    APPEND(comprehensions, e->v.ListComp.generators);
    APPEND_STR_FINISH("]");
}

static int
append_ast_setcomp(_PyUnicodeWriter *writer, expr_ty e)
{
    APPEND_STR("{");
    APPEND_EXPR(e->v.SetComp.elt, PR_TEST);
    APPEND(comprehensions, e->v.SetComp.generators);
    APPEND_STR_FINISH("}");
}

static int
append_ast_dictcomp(_PyUnicodeWriter *writer, expr_ty e)
{
    APPEND_STR("{");
    APPEND_EXPR(e->v.DictComp.key, PR_TEST);
    APPEND_STR(": ");
    APPEND_EXPR(e->v.DictComp.value, PR_TEST);
    APPEND(comprehensions, e->v.DictComp.generators);
    APPEND_STR_FINISH("}");
}

static int
append_ast_compare(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    const char *op;
    Py_ssize_t i, comparator_count;
    asdl_expr_seq *comparators;
    asdl_int_seq *ops;

    APPEND_STR_IF(level > PR_CMP, "(");

    comparators = e->v.Compare.comparators;
    ops = e->v.Compare.ops;
    comparator_count = asdl_seq_LEN(comparators);
    assert(comparator_count > 0);
    assert(comparator_count == asdl_seq_LEN(ops));

    APPEND_EXPR(e->v.Compare.left, PR_CMP + 1);

    for (i = 0; i < comparator_count; i++) {
        switch ((cmpop_ty)asdl_seq_GET(ops, i)) {
        case Eq:
            op = " == ";
            break;
        case NotEq:
            op = " != ";
            break;
        case Lt:
            op = " < ";
            break;
        case LtE:
            op = " <= ";
            break;
        case Gt:
            op = " > ";
            break;
        case GtE:
            op = " >= ";
            break;
        case Is:
            op = " is ";
            break;
        case IsNot:
            op = " is not ";
            break;
        case In:
            op = " in ";
            break;
        case NotIn:
            op = " not in ";
            break;
        default:
            PyErr_SetString(PyExc_SystemError,
                            "unexpected comparison kind");
            return -1;
        }

        APPEND_STR(op);
        APPEND_EXPR((expr_ty)asdl_seq_GET(comparators, i), PR_CMP + 1);
    }

    APPEND_STR_IF(level > PR_CMP, ")");
    return 0;
}

static int
append_ast_keyword(_PyUnicodeWriter *writer, keyword_ty kw)
{
    if (kw->arg == NULL) {
        APPEND_STR("**");
    }
    else {
        if (-1 == _PyUnicodeWriter_WriteStr(writer, kw->arg)) {
            return -1;
        }

        APPEND_STR("=");
    }

    APPEND_EXPR(kw->value, PR_TEST);
    return 0;
}

static int
append_ast_call(_PyUnicodeWriter *writer, expr_ty e)
{
    bool first;
    Py_ssize_t i, arg_count, kw_count;
    expr_ty expr;

    APPEND_EXPR(e->v.Call.func, PR_ATOM);

    arg_count = asdl_seq_LEN(e->v.Call.args);
    kw_count = asdl_seq_LEN(e->v.Call.keywords);
    if (arg_count == 1 && kw_count == 0) {
        expr = (expr_ty)asdl_seq_GET(e->v.Call.args, 0);
        if (expr->kind == GeneratorExp_kind) {
            /* Special case: a single generator expression. */
            return append_ast_genexp(writer, expr);
        }
    }

    APPEND_STR("(");

    first = true;
    for (i = 0; i < arg_count; i++) {
        APPEND_STR_IF_NOT_FIRST(", ");
        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Call.args, i), PR_TEST);
    }

    for (i = 0; i < kw_count; i++) {
        APPEND_STR_IF_NOT_FIRST(", ");
        APPEND(keyword, (keyword_ty)asdl_seq_GET(e->v.Call.keywords, i));
    }

    APPEND_STR_FINISH(")");
}

static PyObject *
escape_braces(PyObject *orig)
{
    PyObject *temp;
    PyObject *result;
    temp = PyUnicode_Replace(orig, &_Py_STR(open_br), &_Py_STR(dbl_open_br), -1);
    if (!temp) {
        return NULL;
    }
    result = PyUnicode_Replace(temp, &_Py_STR(close_br), &_Py_STR(dbl_close_br), -1);
    Py_DECREF(temp);
    return result;
}

static int
append_fstring_unicode(_PyUnicodeWriter *writer, PyObject *unicode)
{
    PyObject *escaped;
    int result = -1;
    escaped = escape_braces(unicode);
    if (escaped) {
        result = _PyUnicodeWriter_WriteStr(writer, escaped);
        Py_DECREF(escaped);
    }
    return result;
}

static int
append_fstring_element(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)
{
    switch (e->kind) {
    case Constant_kind:
        return append_fstring_unicode(writer, e->v.Constant.value);
    case JoinedStr_kind:
        return append_joinedstr(writer, e, is_format_spec);
    case FormattedValue_kind:
        return append_formattedvalue(writer, e);
    default:
        PyErr_SetString(PyExc_SystemError,
                        "unknown expression kind inside f-string");
        return -1;
    }
}

/* Build body separately to enable wrapping the entire stream of Strs,
   Constants and FormattedValues in one opening and one closing quote. */
static PyObject *
build_fstring_body(asdl_expr_seq *values, bool is_format_spec)
{
    Py_ssize_t i, value_count;
    _PyUnicodeWriter body_writer;
    _PyUnicodeWriter_Init(&body_writer);
    body_writer.min_length = 256;
    body_writer.overallocate = 1;

    value_count = asdl_seq_LEN(values);
    for (i = 0; i < value_count; ++i) {
        if (-1 == append_fstring_element(&body_writer,
                                         (expr_ty)asdl_seq_GET(values, i),
                                         is_format_spec
                                         )) {
            _PyUnicodeWriter_Dealloc(&body_writer);
            return NULL;
        }
    }

    return _PyUnicodeWriter_Finish(&body_writer);
}

static int
append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)
{
    int result = -1;
    PyObject *body = build_fstring_body(e->v.JoinedStr.values, is_format_spec);
    if (!body) {
        return -1;
    }

    if (!is_format_spec) {
        if (-1 != append_charp(writer, "f") &&
            -1 != append_repr(writer, body))
        {
            result = 0;
        }
    }
    else {
        result = _PyUnicodeWriter_WriteStr(writer, body);
    }
    Py_DECREF(body);
    return result;
}

static int
append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e)
{
    const char *conversion;
    const char *outer_brace = "{";
    /* Grammar allows PR_TUPLE, but use >PR_TEST for adding parenthesis
       around a lambda with ':' */
    PyObject *temp_fv_str = expr_as_unicode(e->v.FormattedValue.value, PR_TEST + 1);
    if (!temp_fv_str) {
        return -1;
    }
    if (PyUnicode_Find(temp_fv_str, &_Py_STR(open_br), 0, 1, 1) == 0) {
        /* Expression starts with a brace, split it with a space from the outer
           one. */
        outer_brace = "{ ";
    }
    if (-1 == append_charp(writer, outer_brace)) {
        Py_DECREF(temp_fv_str);
        return -1;
    }
    if (-1 == _PyUnicodeWriter_WriteStr(writer, temp_fv_str)) {
        Py_DECREF(temp_fv_str);
        return -1;
    }
    Py_DECREF(temp_fv_str);

    if (e->v.FormattedValue.conversion > 0) {
        switch (e->v.FormattedValue.conversion) {
        case 'a':
            conversion = "!a";
            break;
        case 'r':
            conversion = "!r";
            break;
        case 's':
            conversion = "!s";
            break;
        default:
            PyErr_SetString(PyExc_SystemError,
                            "unknown f-value conversion kind");
            return -1;
        }
        APPEND_STR(conversion);
    }
    if (e->v.FormattedValue.format_spec) {
        if (-1 == _PyUnicodeWriter_WriteASCIIString(writer, ":", 1) ||
            -1 == append_fstring_element(writer,
                                         e->v.FormattedValue.format_spec,
                                         true
                                        ))
        {
            return -1;
        }
    }

    APPEND_STR_FINISH("}");
}

static int
append_ast_constant(_PyUnicodeWriter *writer, PyObject *constant)
{
    if (PyTuple_CheckExact(constant)) {
        Py_ssize_t i, elem_count;

        elem_count = PyTuple_GET_SIZE(constant);
        APPEND_STR("(");
        for (i = 0; i < elem_count; i++) {
            APPEND_STR_IF(i > 0, ", ");
            if (append_ast_constant(writer, PyTuple_GET_ITEM(constant, i)) < 0) {
                return -1;
            }
        }

        APPEND_STR_IF(elem_count == 1, ",");
        APPEND_STR(")");
        return 0;
    }
    return append_repr(writer, constant);
}

static int
append_ast_attribute(_PyUnicodeWriter *writer, expr_ty e)
{
    const char *period;
    expr_ty v = e->v.Attribute.value;
    APPEND_EXPR(v, PR_ATOM);

    /* Special case: integers require a space for attribute access to be
       unambiguous. */
    if (v->kind == Constant_kind && PyLong_CheckExact(v->v.Constant.value)) {
        period = " .";
    }
    else {
        period = ".";
    }
    APPEND_STR(period);

    return _PyUnicodeWriter_WriteStr(writer, e->v.Attribute.attr);
}

static int
append_ast_slice(_PyUnicodeWriter *writer, expr_ty e)
{
    if (e->v.Slice.lower) {
        APPEND_EXPR(e->v.Slice.lower, PR_TEST);
    }

    APPEND_STR(":");

    if (e->v.Slice.upper) {
        APPEND_EXPR(e->v.Slice.upper, PR_TEST);
    }

    if (e->v.Slice.step) {
        APPEND_STR(":");
        APPEND_EXPR(e->v.Slice.step, PR_TEST);
    }
    return 0;
}

static int
append_ast_subscript(_PyUnicodeWriter *writer, expr_ty e)
{
    APPEND_EXPR(e->v.Subscript.value, PR_ATOM);
    APPEND_STR("[");
    APPEND_EXPR(e->v.Subscript.slice, PR_TUPLE);
    APPEND_STR_FINISH("]");
}

static int
append_ast_starred(_PyUnicodeWriter *writer, expr_ty e)
{
    APPEND_STR("*");
    APPEND_EXPR(e->v.Starred.value, PR_EXPR);
    return 0;
}

static int
append_ast_yield(_PyUnicodeWriter *writer, expr_ty e)
{
    if (!e->v.Yield.value) {
        APPEND_STR_FINISH("(yield)");
    }

    APPEND_STR("(yield ");
    APPEND_EXPR(e->v.Yield.value, PR_TEST);
    APPEND_STR_FINISH(")");
}

static int
append_ast_yield_from(_PyUnicodeWriter *writer, expr_ty e)
{
    APPEND_STR("(yield from ");
    APPEND_EXPR(e->v.YieldFrom.value, PR_TEST);
    APPEND_STR_FINISH(")");
}

static int
append_ast_await(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    APPEND_STR_IF(level > PR_AWAIT, "(");
    APPEND_STR("await ");
    APPEND_EXPR(e->v.Await.value, PR_ATOM);
    APPEND_STR_IF(level > PR_AWAIT, ")");
    return 0;
}

static int
append_named_expr(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    APPEND_STR_IF(level > PR_TUPLE, "(");
    APPEND_EXPR(e->v.NamedExpr.target, PR_ATOM);
    APPEND_STR(" := ");
    APPEND_EXPR(e->v.NamedExpr.value, PR_ATOM);
    APPEND_STR_IF(level > PR_TUPLE, ")");
    return 0;
}

static int
append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level)
{
    switch (e->kind) {
    case BoolOp_kind:
        return append_ast_boolop(writer, e, level);
    case BinOp_kind:
        return append_ast_binop(writer, e, level);
    case UnaryOp_kind:
        return append_ast_unaryop(writer, e, level);
    case Lambda_kind:
        return append_ast_lambda(writer, e, level);
    case IfExp_kind:
        return append_ast_ifexp(writer, e, level);
    case Dict_kind:
        return append_ast_dict(writer, e);
    case Set_kind:
        return append_ast_set(writer, e);
    case GeneratorExp_kind:
        return append_ast_genexp(writer, e);
    case ListComp_kind:
        return append_ast_listcomp(writer, e);
    case SetComp_kind:
        return append_ast_setcomp(writer, e);
    case DictComp_kind:
        return append_ast_dictcomp(writer, e);
    case Yield_kind:
        return append_ast_yield(writer, e);
    case YieldFrom_kind:
        return append_ast_yield_from(writer, e);
    case Await_kind:
        return append_ast_await(writer, e, level);
    case Compare_kind:
        return append_ast_compare(writer, e, level);
    case Call_kind:
        return append_ast_call(writer, e);
    case Constant_kind:
        if (e->v.Constant.value == Py_Ellipsis) {
            APPEND_STR_FINISH("...");
        }
        if (e->v.Constant.kind != NULL
            && -1 == _PyUnicodeWriter_WriteStr(writer, e->v.Constant.kind)) {
            return -1;
        }
        return append_ast_constant(writer, e->v.Constant.value);
    case JoinedStr_kind:
        return append_joinedstr(writer, e, false);
    case FormattedValue_kind:
        return append_formattedvalue(writer, e);
    /* The following exprs can be assignment targets. */
    case Attribute_kind:
        return append_ast_attribute(writer, e);
    case Subscript_kind:
        return append_ast_subscript(writer, e);
    case Starred_kind:
        return append_ast_starred(writer, e);
    case Slice_kind:
        return append_ast_slice(writer, e);
    case Name_kind:
        return _PyUnicodeWriter_WriteStr(writer, e->v.Name.id);
    case List_kind:
        return append_ast_list(writer, e);
    case Tuple_kind:
        return append_ast_tuple(writer, e, level);
    case NamedExpr_kind:
        return append_named_expr(writer, e, level);
    // No default so compiler emits a warning for unhandled cases
    }
    PyErr_SetString(PyExc_SystemError,
                    "unknown expression kind");
    return -1;
}

static int
maybe_init_static_strings(void)
{
    PyInterpreterState *interp = _PyInterpreterState_GET();
    if (_str_replace_inf(interp) == NULL) {
        PyObject *tmp = PyUnicode_FromFormat("1e%d", 1 + DBL_MAX_10_EXP);
        if (tmp == NULL) {
            return -1;
        }
        _str_replace_inf(interp) = tmp;
    }
    return 0;
}

static PyObject *
expr_as_unicode(expr_ty e, int level)
{
    _PyUnicodeWriter writer;
    _PyUnicodeWriter_Init(&writer);
    writer.min_length = 256;
    writer.overallocate = 1;
    if (-1 == maybe_init_static_strings() ||
        -1 == append_ast_expr(&writer, e, level))
    {
        _PyUnicodeWriter_Dealloc(&writer);
        return NULL;
    }
    return _PyUnicodeWriter_Finish(&writer);
}

PyObject *
_PyAST_ExprAsUnicode(expr_ty e)
{
    return expr_as_unicode(e, PR_TEST);
}


================================================
FILE: BltinModule.c
================================================
/* Built-in functions */

#include "Python.h"
#include <ctype.h>
#include "pycore_ast.h"           // _PyAST_Validate()
#include "pycore_call.h"          // _PyObject_CallNoArgs()
#include "pycore_compile.h"       // _PyAST_Compile()
#include "pycore_long.h"          // _PyLong_CompactValue
#include "pycore_object.h"        // _Py_AddToAllObjects()
#include "pycore_pyerrors.h"      // _PyErr_NoMemory()
#include "pycore_pystate.h"       // _PyThreadState_GET()
#include "pycore_tuple.h"         // _PyTuple_FromArray()
#include "pycore_ceval.h"         // _PyEval_Vector()

#include "clinic/bltinmodule.c.h"

static PyObject*
update_bases(PyObject *bases, PyObject *const *args, Py_ssize_t nargs)
{
    Py_ssize_t i, j;
    PyObject *base, *meth, *new_base, *result, *new_bases = NULL;
    assert(PyTuple_Check(bases));

    for (i = 0; i < nargs; i++) {
        base  = args[i];
        if (PyType_Check(base)) {
            if (new_bases) {
                /* If we already have made a replacement, then we append every normal base,
                   otherwise just skip it. */
                if (PyList_Append(new_bases, base) < 0) {
                    goto error;
                }
            }
            continue;
        }
        if (_PyObject_LookupAttr(base, &_Py_ID(__mro_entries__), &meth) < 0) {
            goto error;
        }
        if (!meth) {
            if (new_bases) {
                if (PyList_Append(new_bases, base) < 0) {
                    goto error;
                }
            }
            continue;
        }
        new_base = PyObject_CallOneArg(meth, bases);
        Py_DECREF(meth);
        if (!new_base) {
            goto error;
        }
        if (!PyTuple_Check(new_base)) {
            PyErr_SetString(PyExc_TypeError,
                            "__mro_entries__ must return a tuple");
            Py_DECREF(new_base);
            goto error;
        }
        if (!new_bases) {
            /* If this is a first successful replacement, create new_bases list and
               copy previously encountered bases. */
            if (!(new_bases = PyList_New(i))) {
                Py_DECREF(new_base);
                goto error;
            }
            for (j = 0; j < i; j++) {
                base = args[j];
                PyList_SET_ITEM(new_bases, j, Py_NewRef(base));
            }
        }
        j = PyList_GET_SIZE(new_bases);
        if (PyList_SetSlice(new_bases, j, j, new_base) < 0) {
            Py_DECREF(new_base);
            goto error;
        }
        Py_DECREF(new_base);
    }
    if (!new_bases) {
        return bases;
    }
    result = PyList_AsTuple(new_bases);
    Py_DECREF(new_bases);
    return result;

error:
    Py_XDECREF(new_bases);
    return NULL;
}

/* AC: cannot convert yet, waiting for *args support */
static PyObject *
builtin___build_class__(PyObject *self, PyObject *const *args, Py_ssize_t nargs,
                        PyObject *kwnames)
{
    PyObject *func, *name, *winner, *prep;
    PyObject *cls = NULL, *cell = NULL, *ns = NULL, *meta = NULL, *orig_bases = NULL;
    PyObject *mkw = NULL, *bases = NULL;
    int isclass = 0;   /* initialize to prevent gcc warning */

    if (nargs < 2) {
        PyErr_SetString(PyExc_TypeError,
                        "__build_class__: not enough arguments");
        return NULL;
    }
    func = args[0];   /* Better be callable */
    if (!PyFunction_Check(func)) {
        PyErr_SetString(PyExc_TypeError,
                        "__build_class__: func must be a function");
        return NULL;
    }
    name = args[1];
    if (!PyUnicode_Check(name)) {
        PyErr_SetString(PyExc_TypeError,
                        "__build_class__: name is not a string");
        return NULL;
    }
    orig_bases = _PyTuple_FromArray(args + 2, nargs - 2);
    if (orig_bases == NULL)
        return NULL;

    bases = update_bases(orig_bases, args + 2, nargs - 2);
    if (bases == NULL) {
        Py_DECREF(orig_bases);
        return NULL;
    }

    if (kwnames == NULL) {
        meta = NULL;
        mkw = NULL;
    }
    else {
        mkw = _PyStack_AsDict(args + nargs, kwnames);
        if (mkw == NULL) {
            goto error;
        }

        meta = _PyDict_GetItemWithError(mkw, &_Py_ID(metaclass));
        if (meta != NULL) {
            Py_INCREF(meta);
            if (PyDict_DelItem(mkw, &_Py_ID(metaclass)) < 0) {
                goto error;
            }
            /* metaclass is explicitly given, check if it's indeed a class */
            isclass = PyType_Check(meta);
        }
        else if (PyErr_Occurred()) {
            goto error;
        }
    }
    if (meta == NULL) {
        /* if there are no bases, use type: */
        if (PyTuple_GET_SIZE(bases) == 0) {
            meta = (PyObject *) (&PyType_Type);
        }
        /* else get the type of the first base */
        else {
            PyObject *base0 = PyTuple_GET_ITEM(bases, 0);
            meta = (PyObject *)Py_TYPE(base0);
        }
        Py_INCREF(meta);
        isclass = 1;  /* meta is really a class */
    }

    if (isclass) {
        /* meta is really a class, so check for a more derived
           metaclass, or possible metaclass conflicts: */
        winner = (PyObject *)_PyType_CalculateMetaclass((PyTypeObject *)meta,
                                                        bases);
        if (winner == NULL) {
            goto error;
        }
        if (winner != meta) {
            Py_SETREF(meta, Py_NewRef(winner));
        }
    }
    /* else: meta is not a class, so we cannot do the metaclass
       calculation, so we will use the explicitly given object as it is */
    if (_PyObject_LookupAttr(meta, &_Py_ID(__prepare__), &prep) < 0) {
        ns = NULL;
    }
    else if (prep == NULL) {
        ns = PyDict_New();
    }
    else {
        PyObject *pargs[2] = {name, bases};
        ns = PyObject_VectorcallDict(prep, pargs, 2, mkw);
        Py_DECREF(prep);
    }
    if (ns == NULL) {
        goto error;
    }
    if (!PyMapping_Check(ns)) {
        PyErr_Format(PyExc_TypeError,
                     "%.200s.__prepare__() must return a mapping, not %.200s",
                     isclass ? ((PyTypeObject *)meta)->tp_name : "<metaclass>",
                     Py_TYPE(ns)->tp_name);
        goto error;
    }
    PyThreadState *tstate = _PyThreadState_GET();
    EVAL_CALL_STAT_INC(EVAL_CALL_BUILD_CLASS);
    cell = _PyEval_Vector(tstate, (PyFunctionObject *)func, ns, NULL, 0, NULL);
    if (cell != NULL) {
        if (bases != orig_bases) {
            if (PyMapping_SetItemString(ns, "__orig_bases__", orig_bases) < 0) {
                goto error;
            }
        }
        PyObject *margs[3] = {name, bases, ns};
        cls = PyObject_VectorcallDict(meta, margs, 3, mkw);
        if (cls != NULL && PyType_Check(cls) && PyCell_Check(cell)) {
            PyObject *cell_cls = PyCell_GET(cell);
            if (cell_cls != cls) {
                if (cell_cls == NULL) {
                    const char *msg =
                        "__class__ not set defining %.200R as %.200R. "
                        "Was __classcell__ propagated to type.__new__?";
                    PyErr_Format(PyExc_RuntimeError, msg, name, cls);
                } else {
                    const char *msg =
                        "__class__ set to %.200R defining %.200R as %.200R";
                    PyErr_Format(PyExc_TypeError, msg, cell_cls, name, cls);
                }
                Py_SETREF(cls, NULL);
                goto error;
            }
        }
    }
error:
    Py_XDECREF(cell);
    Py_XDECREF(ns);
    Py_XDECREF(meta);
    Py_XDECREF(mkw);
    if (bases != orig_bases) {
        Py_DECREF(orig_bases);
    }
    Py_DECREF(bases);
    return cls;
}

PyDoc_STRVAR(build_class_doc,
"__build_class__(func, name, /, *bases, [metaclass], **kwds) -> class\n\
\n\
Internal helper function used by the class statement.");

/*[clinic input]
__import__ as builtin___import__

    name: object
    globals: object(c_default="NULL") = None
    locals: object(c_default="NULL") = None
    fromlist: object(c_default="NULL") = ()
    level: int = 0

Import a module.

Because this function is meant for use by the Python
interpreter and not for general use, it is better to use
importlib.import_module() to programmatically import a module.

The globals argument is only used to determine the context;
they are not modified.  The locals argument is unused.  The fromlist
should be a list of names to emulate ``from name import ...``, or an
empty list to emulate ``import name``.
When importing a module from a package, note that __import__('A.B', ...)
returns package A when fromlist is empty, but its submodule B when
fromlist is not empty.  The level argument is used to determine whether to
perform absolute or relative imports: 0 is absolute, while a positive number
is the number of parent directories to search relative to the current module.
[clinic start generated code]*/

static PyObject *
builtin___import___impl(PyObject *module, PyObject *name, PyObject *globals,
                        PyObject *locals, PyObject *fromlist, int level)
/*[clinic end generated code: output=4febeda88a0cd245 input=73f4b960ea5b9dd6]*/
{
    return PyImport_ImportModuleLevelObject(name, globals, locals,
                                            fromlist, level);
}


/*[clinic input]
abs as builtin_abs

    x: object
    /

Return the absolute value of the argument.
[clinic start generated code]*/

static PyObject *
builtin_abs(PyObject *module, PyObject *x)
/*[clinic end generated code: output=b1b433b9e51356f5 input=bed4ca14e29c20d1]*/
{
    return PyNumber_Absolute(x);
}

/*[clinic input]
all as builtin_all

    iterable: object
    /

Return True if bool(x) is True for all values x in the iterable.

If the iterable is empty, return True.
[clinic start generated code]*/

static PyObject *
builtin_all(PyObject *module, PyObject *iterable)
/*[clinic end generated code: output=ca2a7127276f79b3 input=1a7c5d1bc3438a21]*/
{
    PyObject *it, *item;
    PyObject *(*iternext)(PyObject *);
    int cmp;

    it = PyObject_GetIter(iterable);
    if (it == NULL)
        return NULL;
    iternext = *Py_TYPE(it)->tp_iternext;

    for (;;) {
        item = iternext(it);
        if (item == NULL)
            break;
        cmp = PyObject_IsTrue(item);
        Py_DECREF(item);
        if (cmp < 0) {
            Py_DECREF(it);
            return NULL;
        }
        if (cmp == 0) {
            Py_DECREF(it);
            Py_RETURN_FALSE;
        }
    }
    Py_DECREF(it);
    if (PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_StopIteration))
            PyErr_Clear();
        else
            return NULL;
    }
    Py_RETURN_TRUE;
}

/*[clinic input]
any as builtin_any

    iterable: object
    /

Return True if bool(x) is True for any x in the iterable.

If the iterable is empty, return False.
[clinic start generated code]*/

static PyObject *
builtin_any(PyObject *module, PyObject *iterable)
/*[clinic end generated code: output=fa65684748caa60e input=41d7451c23384f24]*/
{
    PyObject *it, *item;
    PyObject *(*iternext)(PyObject *);
    int cmp;

    it = PyObject_GetIter(iterable);
    if (it == NULL)
        return NULL;
    iternext = *Py_TYPE(it)->tp_iternext;

    for (;;) {
        item = iternext(it);
        if (item == NULL)
            break;
        cmp = PyObject_IsTrue(item);
        Py_DECREF(item);
        if (cmp < 0) {
            Py_DECREF(it);
            return NULL;
        }
        if (cmp > 0) {
            Py_DECREF(it);
            Py_RETURN_TRUE;
        }
    }
    Py_DECREF(it);
    if (PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_StopIteration))
            PyErr_Clear();
        else
            return NULL;
    }
    Py_RETURN_FALSE;
}

/*[clinic input]
ascii as builtin_ascii

    obj: object
    /

Return an ASCII-only representation of an object.

As repr(), return a string containing a printable representation of an
object, but escape the non-ASCII characters in the string returned by
repr() using \\x, \\u or \\U escapes. This generates a string similar
to that returned by repr() in Python 2.
[clinic start generated code]*/

static PyObject *
builtin_ascii(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=6d37b3f0984c7eb9 input=4c62732e1b3a3cc9]*/
{
    return PyObject_ASCII(obj);
}


/*[clinic input]
bin as builtin_bin

    number: object
    /

Return the binary representation of an integer.

   >>> bin(2796202)
   '0b1010101010101010101010'
[clinic start generated code]*/

static PyObject *
builtin_bin(PyObject *module, PyObject *number)
/*[clinic end generated code: output=b6fc4ad5e649f4f7 input=53f8a0264bacaf90]*/
{
    return PyNumber_ToBase(number, 2);
}


/*[clinic input]
callable as builtin_callable

    obj: object
    /

Return whether the object is callable (i.e., some kind of function).

Note that classes are callable, as are instances of classes with a
__call__() method.
[clinic start generated code]*/

static PyObject *
builtin_callable(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=2b095d59d934cb7e input=1423bab99cc41f58]*/
{
    return PyBool_FromLong((long)PyCallable_Check(obj));
}

static PyObject *
builtin_breakpoint(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *keywords)
{
    PyObject *hook = PySys_GetObject("breakpointhook");

    if (hook == NULL) {
        PyErr_SetString(PyExc_RuntimeError, "lost sys.breakpointhook");
        return NULL;
    }

    if (PySys_Audit("builtins.breakpoint", "O", hook) < 0) {
        return NULL;
    }

    Py_INCREF(hook);
    PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);
    Py_DECREF(hook);
    return retval;
}

PyDoc_STRVAR(breakpoint_doc,
"breakpoint(*args, **kws)\n\
\n\
Call sys.breakpointhook(*args, **kws).  sys.breakpointhook() must accept\n\
whatever arguments are passed.\n\
\n\
By default, this drops you into the pdb debugger.");

typedef struct {
    PyObject_HEAD
    PyObject *func;
    PyObject *it;
} filterobject;

static PyObject *
filter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    PyObject *func, *seq;
    PyObject *it;
    filterobject *lz;

    if ((type == &PyFilter_Type || type->tp_init == PyFilter_Type.tp_init) &&
        !_PyArg_NoKeywords("filter", kwds))
        return NULL;

    if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
        return NULL;

    /* Get iterator. */
    it = PyObject_GetIter(seq);
    if (it == NULL)
        return NULL;

    /* create filterobject structure */
    lz = (filterobject *)type->tp_alloc(type, 0);
    if (lz == NULL) {
        Py_DECREF(it);
        return NULL;
    }

    lz->func = Py_NewRef(func);
    lz->it = it;

    return (PyObject *)lz;
}

static PyObject *
filter_vectorcall(PyObject *type, PyObject * const*args,
                size_t nargsf, PyObject *kwnames)
{
    PyTypeObject *tp = _PyType_CAST(type);
    if (tp == &PyFilter_Type && !_PyArg_NoKwnames("filter", kwnames)) {
        return NULL;
    }

    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
    if (!_PyArg_CheckPositional("filter", nargs, 2, 2)) {
        return NULL;
    }

    PyObject *it = PyObject_GetIter(args[1]);
    if (it == NULL) {
        return NULL;
    }

    filterobject *lz = (filterobject *)tp->tp_alloc(tp, 0);

    if (lz == NULL) {
        Py_DECREF(it);
        return NULL;
    }

    lz->func = Py_NewRef(args[0]);
    lz->it = it;

    return (PyObject *)lz;
}

static void
filter_dealloc(filterobject *lz)
{
    PyObject_GC_UnTrack(lz);
    Py_TRASHCAN_BEGIN(lz, filter_dealloc)
    Py_XDECREF(lz->func);
    Py_XDECREF(lz->it);
    Py_TYPE(lz)->tp_free(lz);
    Py_TRASHCAN_END
}

static int
filter_traverse(filterobject *lz, visitproc visit, void *arg)
{
    Py_VISIT(lz->it);
    Py_VISIT(lz->func);
    return 0;
}

static PyObject *
filter_next(filterobject *lz)
{
    PyObject *item;
    PyObject *it = lz->it;
    long ok;
    PyObject *(*iternext)(PyObject *);
    int checktrue = lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type;

    iternext = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        item = iternext(it);
        if (item == NULL)
            return NULL;

        if (checktrue) {
            ok = PyObject_IsTrue(item);
        } else {
            PyObject *good;
            good = PyObject_CallOneArg(lz->func, item);
            if (good == NULL) {
                Py_DECREF(item);
                return NULL;
            }
            ok = PyObject_IsTrue(good);
            Py_DECREF(good);
        }
        if (ok > 0)
            return item;
        Py_DECREF(item);
        if (ok < 0)
            return NULL;
    }
}

static PyObject *
filter_reduce(filterobject *lz, PyObject *Py_UNUSED(ignored))
{
    return Py_BuildValue("O(OO)", Py_TYPE(lz), lz->func, lz->it);
}

PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");

static PyMethodDef filter_methods[] = {
    {"__reduce__", _PyCFunction_CAST(filter_reduce), METH_NOARGS, reduce_doc},
    {NULL,           NULL}           /* sentinel */
};

PyDoc_STRVAR(filter_doc,
"filter(function or None, iterable) --> filter object\n\
\n\
Return an iterator yielding those items of iterable for which function(item)\n\
is true. If function is None, return the items that are true.");

PyTypeObject PyFilter_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "filter",                           /* tp_name */
    sizeof(filterobject),               /* tp_basicsize */
    0,                                  /* tp_itemsize */
    /* methods */
    (destructor)filter_dealloc,         /* tp_dealloc */
    0,                                  /* tp_vectorcall_offset */
    0,                                  /* tp_getattr */
    0,                                  /* tp_setattr */
    0,                                  /* tp_as_async */
    0,                                  /* tp_repr */
    0,                                  /* tp_as_number */
    0,                                  /* tp_as_sequence */
    0,                                  /* tp_as_mapping */
    0,                                  /* tp_hash */
    0,                                  /* tp_call */
    0,                                  /* tp_str */
    PyObject_GenericGetAttr,            /* tp_getattro */
    0,                                  /* tp_setattro */
    0,                                  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
        Py_TPFLAGS_BASETYPE,            /* tp_flags */
    filter_doc,                         /* tp_doc */
    (traverseproc)filter_traverse,      /* tp_traverse */
    0,                                  /* tp_clear */
    0,                                  /* tp_richcompare */
    0,                                  /* tp_weaklistoffset */
    PyObject_SelfIter,                  /* tp_iter */
    (iternextfunc)filter_next,          /* tp_iternext */
    filter_methods,                     /* tp_methods */
    0,                                  /* tp_members */
    0,                                  /* tp_getset */
    0,                                  /* tp_base */
    0,                                  /* tp_dict */
    0,                                  /* tp_descr_get */
    0,                                  /* tp_descr_set */
    0,                                  /* tp_dictoffset */
    0,                                  /* tp_init */
    PyType_GenericAlloc,                /* tp_alloc */
    filter_new,                         /* tp_new */
    PyObject_GC_Del,                    /* tp_free */
    .tp_vectorcall = (vectorcallfunc)filter_vectorcall
};


/*[clinic input]
format as builtin_format

    value: object
    format_spec: unicode(c_default="NULL") = ''
    /

Return type(value).__format__(value, format_spec)

Many built-in types implement format_spec according to the
Format Specification Mini-language. See help('FORMATTING').

If type(value) does not supply a method named __format__
and format_spec is empty, then str(value) is returned.
See also help('SPECIALMETHODS').
[clinic start generated code]*/

static PyObject *
builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec)
/*[clinic end generated code: output=2f40bdfa4954b077 input=45ef3934b86d5624]*/
{
    return PyObject_Format(value, format_spec);
}

/*[clinic input]
chr as builtin_chr

    i: int
    /

Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
[clinic start generated code]*/

static PyObject *
builtin_chr_impl(PyObject *module, int i)
/*[clinic end generated code: output=c733afcd200afcb7 input=3f604ef45a70750d]*/
{
    return PyUnicode_FromOrdinal(i);
}


/*[clinic input]
compile as builtin_compile

    source: object
    filename: object(converter="PyUnicode_FSDecoder")
    mode: str
    flags: int = 0
    dont_inherit: bool = False
    optimize: int = -1
    *
    _feature_version as feature_version: int = -1

Compile source into a code object that can be executed by exec() or eval().

The source code may represent a Python module, statement or expression.
The filename will be used for run-time error messages.
The mode must be 'exec' to compile a module, 'single' to compile a
single (interactive) statement, or 'eval' to compile an expression.
The flags argument, if present, controls which future statements influence
the compilation of the code.
The dont_inherit argument, if true, stops the compilation inheriting
the effects of any future statements in effect in the code calling
compile; if absent or false these statements do influence the compilation,
in addition to any features explicitly specified.
[clinic start generated code]*/

static PyObject *
builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
                     const char *mode, int flags, int dont_inherit,
                     int optimize, int feature_version)
/*[clinic end generated code: output=b0c09c84f116d3d7 input=cc78e20e7c7682ba]*/
{
    PyObject *source_copy;
    const char *str;
    int compile_mode = -1;
    int is_ast;
    int start[] = {Py_file_input, Py_eval_input, Py_single_input, Py_func_type_input};
    PyObject *result;

    PyCompilerFlags cf = _PyCompilerFlags_INIT;
    cf.cf_flags = flags | PyCF_SOURCE_IS_UTF8;
    if (feature_version >= 0 && (flags & PyCF_ONLY_AST)) {
        cf.cf_feature_version = feature_version;
    }

    if (flags &
        ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_COMPILE_MASK))
    {
        PyErr_SetString(PyExc_ValueError,
                        "compile(): unrecognised flags");
        goto error;
    }
    /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */

    if (optimize < -1 || optimize > 2) {
        PyErr_SetString(PyExc_ValueError,
                        "compile(): invalid optimize value");
        goto error;
    }

    if (!dont_inherit) {
        PyEval_MergeCompilerFlags(&cf);
    }

    if (strcmp(mode, "exec") == 0)
        compile_mode = 0;
    else if (strcmp(mode, "eval") == 0)
        compile_mode = 1;
    else if (strcmp(mode, "single") == 0)
        compile_mode = 2;
    else if (strcmp(mode, "func_type") == 0) {
        if (!(flags & PyCF_ONLY_AST)) {
            PyErr_SetString(PyExc_ValueError,
                            "compile() mode 'func_type' requires flag PyCF_ONLY_AST");
            goto error;
        }
        compile_mode = 3;
    }
    else {
        const char *msg;
        if (flags & PyCF_ONLY_AST)
            msg = "compile() mode must be 'exec', 'eval', 'single' or 'func_type'";
        else
            msg = "compile() mode must be 'exec', 'eval' or 'single'";
        PyErr_SetString(PyExc_ValueError, msg);
        goto error;
    }

    is_ast = PyAST_Check(source);
    if (is_ast == -1)
        goto error;
    if (is_ast) {
        if (flags & PyCF_ONLY_AST) {
            result = Py_NewRef(source);
        }
        else {
            PyArena *arena;
            mod_ty mod;

            arena = _PyArena_New();
            if (arena == NULL)
                goto error;
            mod = PyAST_obj2mod(source, arena, compile_mode);
            if (mod == NULL || !_PyAST_Validate(mod)) {
                _PyArena_Free(arena);
                goto error;
            }
            result = (PyObject*)_PyAST_Compile(mod, filename,
                                               &cf, optimize, arena);
            _PyArena_Free(arena);
        }
        goto finally;
    }

    str = _Py_SourceAsString(source, "compile", "string, bytes or AST", &cf, &source_copy);
    if (str == NULL)
        goto error;

    result = Py_CompileStringObject(str, filename, start[compile_mode], &cf, optimize);

    Py_XDECREF(source_copy);
    goto finally;

error:
    result = NULL;
finally:
    Py_DECREF(filename);
    return result;
}

/*[clinic input]
dir as builtin_dir

    arg: object = NULL
    /

Show attributes of an object.

If called without an argument, return the names in the current scope.
Else, return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it.
If the object supplies a method named __dir__, it will be used; otherwise
the default dir() logic is used and returns:
  for a module object: the module's attributes.
  for a class object:  its attributes, and recursively the attributes
    of its bases.
  for any other object: its attributes, its class's attributes, and
    recursively the attributes of its class's base classes.
[clinic start generated code]*/

static PyObject *
builtin_dir_impl(PyObject *module, PyObject *arg)
/*[clinic end generated code: output=24f2c7a52c1e3b08 input=ed6d6ccb13d52251]*/
{
    return PyObject_Dir(arg);
}

/*[clinic input]
divmod as builtin_divmod

    x: object
    y: object
    /

Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
[clinic start generated code]*/

static PyObject *
builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y)
/*[clinic end generated code: output=b06d8a5f6e0c745e input=175ad9c84ff41a85]*/
{
    return PyNumber_Divmod(x, y);
}


/*[clinic input]
eval as builtin_eval

    source: object
    globals: object = None
    locals: object = None
    /

Evaluate the given source in the context of globals and locals.

The source may be a string representing a Python expression
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.
[clinic start generated code]*/

static PyObject *
builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
                  PyObject *locals)
/*[clinic end generated code: output=0a0824aa70093116 input=11ee718a8640e527]*/
{
    PyObject *result, *source_copy;
    const char *str;

    if (locals != Py_None && !PyMapping_Check(locals)) {
        PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
        return NULL;
    }
    if (globals != Py_None && !PyDict_Check(globals)) {
        PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
            "globals must be a real dict; try eval(expr, {}, mapping)"
            : "globals must be a dict");
        return NULL;
    }
    if (globals == Py_None) {
        globals = PyEval_GetGlobals();
        if (locals == Py_None) {
            locals = PyEval_GetLocals();
            if (locals == NULL)
                return NULL;
        }
    }
    else if (locals == Py_None)
        locals = globals;

    if (globals == NULL || locals == NULL) {
        PyErr_SetString(PyExc_TypeError,
            "eval must be given globals and locals "
            "when called without a frame");
        return NULL;
    }

    int r = PyDict_Contains(globals, &_Py_ID(__builtins__));
    if (r == 0) {
        r = PyDict_SetItem(globals, &_Py_ID(__builtins__), PyEval_GetBuiltins());
    }
    if (r < 0) {
        return NULL;
    }

    if (PyCode_Check(source)) {
        if (PySys_Audit("exec", "O", source) < 0) {
            return NULL;
        }

        if (PyCode_GetNumFree((PyCodeObject *)source) > 0) {
            PyErr_SetString(PyExc_TypeError,
                "code object passed to eval() may not contain free variables");
            return NULL;
        }
        return PyEval_EvalCode(source, globals, locals);
    }

    PyCompilerFlags cf = _PyCompilerFlags_INIT;
    cf.cf_flags = PyCF_SOURCE_IS_UTF8;
    str = _Py_SourceAsString(source, "eval", "string, bytes or code", &cf, &source_copy);
    if (str == NULL)
        return NULL;

    while (*str == ' ' || *str == '\t')
        str++;

    (void)PyEval_MergeCompilerFlags(&cf);
    result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
    Py_XDECREF(source_copy);
    return result;
}

/*[clinic input]
exec as builtin_exec

    source: object
    globals: object = None
    locals: object = None
    /
    *
    closure: object(c_default="NULL") = None

Execute the given source in the context of globals and locals.

The source may be a string representing one or more Python statements
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.
The closure must be a tuple of cellvars, and can only be used
when source is a code object requiring exactly that many cellvars.
[clinic start generated code]*/

static PyObject *
builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
                  PyObject *locals, PyObject *closure)
/*[clinic end generated code: output=7579eb4e7646743d input=f13a7e2b503d1d9a]*/
{
    PyObject *v;

    if (globals == Py_None) {
        globals = PyEval_GetGlobals();
        if (locals == Py_None) {
            locals = PyEval_GetLocals();
            if (locals == NULL)
                return NULL;
        }
        if (!globals || !locals) {
            PyErr_SetString(PyExc_SystemError,
                            "globals and locals cannot be NULL");
            return NULL;
        }
    }
    else if (locals == Py_None)
        locals = globals;

    if (!PyDict_Check(globals)) {
        PyErr_Format(PyExc_TypeError, "exec() globals must be a dict, not %.100s",
                     Py_TYPE(globals)->tp_name);
        return NULL;
    }
    if (!PyMapping_Check(locals)) {
        PyErr_Format(PyExc_TypeError,
            "locals must be a mapping or None, not %.100s",
            Py_TYPE(locals)->tp_name);
        return NULL;
    }
    int r = PyDict_Contains(globals, &_Py_ID(__builtins__));
    if (r == 0) {
        r = PyDict_SetItem(globals, &_Py_ID(__builtins__), PyEval_GetBuiltins());
    }
    if (r < 0) {
        return NULL;
    }

    if (closure == Py_None) {
        closure = NULL;
    }

    if (PyCode_Check(source)) {
        Py_ssize_t num_free = PyCode_GetNumFree((PyCodeObject *)source);
        if (num_free == 0) {
            if (closure) {
                PyErr_SetString(PyExc_TypeError,
                    "cannot use a closure with this code object");
                return NULL;
            }
        } else {
            int closure_is_ok =
                closure
                && PyTuple_CheckExact(closure)
                && (PyTuple_GET_SIZE(closure) == num_free);
            if (closure_is_ok) {
                for (Py_ssize_t i = 0; i < num_free; i++) {
                    PyObject *cell = PyTuple_GET_ITEM(closure, i);
                    if (!PyCell_Check(cell)) {
                        closure_is_ok = 0;
                        break;
                    }
                }
            }
            if (!closure_is_ok) {
                PyErr_Format(PyExc_TypeError,
                    "code object requires a closure of exactly length %zd",
                    num_free);
                return NULL;
            }
        }

        if (PySys_Audit("exec", "O", source) < 0) {
            return NULL;
        }

        if (!closure) {
            v = PyEval_EvalCode(source, globals, locals);
        } else {
            v = PyEval_EvalCodeEx(source, globals, locals,
                NULL, 0,
                NULL, 0,
                NULL, 0,
                NULL,
                closure);
        }
    }
    else {
        if (closure != NULL) {
            PyErr_SetString(PyExc_TypeError,
                "closure can only be used when source is a code object");
        }
        PyObject *source_copy;
        const char *str;
        PyCompilerFlags cf = _PyCompilerFlags_INIT;
        cf.cf_flags = PyCF_SOURCE_IS_UTF8;
        str = _Py_SourceAsString(source, "exec",
                                       "string, bytes or code", &cf,
                                       &source_copy);
        if (str == NULL)
            return NULL;
        if (PyEval_MergeCompilerFlags(&cf))
            v = PyRun_StringFlags(str, Py_file_input, globals,
                                  locals, &cf);
        else
            v = PyRun_String(str, Py_file_input, globals, locals);
        Py_XDECREF(source_copy);
    }
    if (v == NULL)
        return NULL;
    Py_DECREF(v);
    Py_RETURN_NONE;
}


/*[clinic input]
getattr as builtin_getattr

    object: object
    name: object
    default: object = NULL
    /

Get a named attribute from an object.

getattr(x, 'y') is equivalent to x.y
When a default argument is given, it is returned when the attribute doesn't
exist; without it, an exception is raised in that case.
[clinic start generated code]*/

static PyObject *
builtin_getattr_impl(PyObject *module, PyObject *object, PyObject *name,
                     PyObject *default_value)
/*[clinic end generated code: output=74ad0e225e3f701c input=d7562cd4c3556171]*/
{
    PyObject *result;

    if (default_value != NULL) {
        if (_PyObject_LookupAttr(object, name, &result) == 0) {
            return Py_NewRef(default_value);
        }
    }
    else {
        result = PyObject_GetAttr(object, name);
    }
    return result;
}


/*[clinic input]
globals as builtin_globals

Return the dictionary containing the current scope's global variables.

NOTE: Updates to this dictionary *will* affect name lookups in the current
global scope and vice-versa.
[clinic start generated code]*/

static PyObject *
builtin_globals_impl(PyObject *module)
/*[clinic end generated code: output=e5dd1527067b94d2 input=9327576f92bb48ba]*/
{
    PyObject *d;

    d = PyEval_GetGlobals();
    return Py_XNewRef(d);
}


/*[clinic input]
hasattr as builtin_hasattr

    obj: object
    name: object
    /

Return whether the object has an attribute with the given name.

This is done by calling getattr(obj, name) and catching AttributeError.
[clinic start generated code]*/

static PyObject *
builtin_hasattr_impl(PyObject *module, PyObject *obj, PyObject *name)
/*[clinic end generated code: output=a7aff2090a4151e5 input=0faec9787d979542]*/
{
    PyObject *v;

    if (_PyObject_LookupAttr(obj, name, &v) < 0) {
        return NULL;
    }
    if (v == NULL) {
        Py_RETURN_FALSE;
    }
    Py_DECREF(v);
    Py_RETURN_TRUE;
}


/* AC: gdb's integration with CPython relies on builtin_id having
 * the *exact* parameter names of "self" and "v", so we ensure we
 * preserve those name rather than using the AC defaults.
 */
/*[clinic input]
id as builtin_id

    self: self(type="PyModuleDef *")
    obj as v: object
    /

Return the identity of an object.

This is guaranteed to be unique among simultaneously existing objects.
(CPython uses the object's memory address.)
[clinic start generated code]*/

static PyObject *
builtin_id(PyModuleDef *self, PyObject *v)
/*[clinic end generated code: output=0aa640785f697f65 input=5a534136419631f4]*/
{
    PyObject *id = PyLong_FromVoidPtr(v);

    if (id && PySys_Audit("builtins.id", "O", id) < 0) {
        Py_DECREF(id);
        return NULL;
    }

    return id;
}


/* map object ************************************************************/

typedef struct {
    PyObject_HEAD
    PyObject *iters;
    PyObject *func;
} mapobject;

static PyObject *
map_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    PyObject *it, *iters, *func;
    mapobject *lz;
    Py_ssize_t numargs, i;

    if ((type == &PyMap_Type || type->tp_init == PyMap_Type.tp_init) &&
        !_PyArg_NoKeywords("map", kwds))
        return NULL;

    numargs = PyTuple_Size(args);
    if (numargs < 2) {
        PyErr_SetString(PyExc_TypeError,
           "map() must have at least two arguments.");
        return NULL;
    }

    iters = PyTuple_New(numargs-1);
    if (iters == NULL)
        return NULL;

    for (i=1 ; i<numargs ; i++) {
        /* Get iterator. */
        it = PyObject_GetIter(PyTuple_GET_ITEM(args, i));
        if (it == NULL) {
            Py_DECREF(iters);
            return NULL;
        }
        PyTuple_SET_ITEM(iters, i-1, it);
    }

    /* create mapobject structure */
    lz = (mapobject *)type->tp_alloc(type, 0);
    if (lz == NULL) {
        Py_DECREF(iters);
        return NULL;
    }
    lz->iters = iters;
    func = PyTuple_GET_ITEM(args, 0);
    lz->func = Py_NewRef(func);

    return (PyObject *)lz;
}

static PyObject *
map_vectorcall(PyObject *type, PyObject * const*args,
                size_t nargsf, PyObject *kwnames)
{
    PyTypeObject *tp = _PyType_CAST(type);
    if (tp == &PyMap_Type && !_PyArg_NoKwnames("map", kwnames)) {
        return NULL;
    }

    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
    if (nargs < 2) {
        PyErr_SetString(PyExc_TypeError,
           "map() must have at least two arguments.");
        return NULL;
    }

    PyObject *iters = PyTuple_New(nargs-1);
    if (iters == NULL) {
        return NULL;
    }

    for (int i=1; i<nargs; i++) {
        PyObject *it = PyObject_GetIter(args[i]);
        if (it == NULL) {
            Py_DECREF(iters);
            return NULL;
        }
        PyTuple_SET_ITEM(iters, i-1, it);
    }

    mapobject *lz = (mapobject *)tp->tp_alloc(tp, 0);
    if (lz == NULL) {
        Py_DECREF(iters);
        return NULL;
    }
    lz->iters = iters;
    lz->func = Py_NewRef(args[0]);

    return (PyObject *)lz;
}

static void
map_dealloc(mapobject *lz)
{
    PyObject_GC_UnTrack(lz);
    Py_XDECREF(lz->iters);
    Py_XDECREF(lz->func);
    Py_TYPE(lz)->tp_free(lz);
}

static int
map_traverse(mapobject *lz, visitproc visit, void *arg)
{
    Py_VISIT(lz->iters);
    Py_VISIT(lz->func);
    return 0;
}

static PyObject *
map_next(mapobject *lz)
{
    PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];
    PyObject **stack;
    PyObject *result = NULL;
    PyThreadState *tstate = _PyThreadState_GET();

    const Py_ssize_t niters = PyTuple_GET_SIZE(lz->iters);
    if (niters <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) {
        stack = small_stack;
    }
    else {
        stack = PyMem_Malloc(niters * sizeof(stack[0]));
        if (stack == NULL) {
            _PyErr_NoMemory(tstate);
            return NULL;
        }
    }

    Py_ssize_t nargs = 0;
    for (Py_ssize_t i=0; i < niters; i++) {
        PyObject *it = PyTuple_GET_ITEM(lz->iters, i);
        PyObject *val = Py_TYPE(it)->tp_iternext(it);
        if (val == NULL) {
            goto exit;
        }
        stack[i] = val;
        nargs++;
    }

    result = _PyObject_VectorcallTstate(tstate, lz->func, stack, nargs, NULL);

exit:
    for (Py_ssize_t i=0; i < nargs; i++) {
        Py_DECREF(stack[i]);
    }
    if (stack != small_stack) {
        PyMem_Free(stack);
    }
    return result;
}

static PyObject *
map_reduce(mapobject *lz, PyObject *Py_UNUSED(ignored))
{
    Py_ssize_t numargs = PyTuple_GET_SIZE(lz->iters);
    PyObject *args = PyTuple_New(numargs+1);
    Py_ssize_t i;
    if (args == NULL)
        return NULL;
    PyTuple_SET_ITEM(args, 0, Py_NewRef(lz->func));
    for (i = 0; i<numargs; i++){
        PyObject *it = PyTuple_GET_ITEM(lz->iters, i);
        PyTuple_SET_ITEM(args, i+1, Py_NewRef(it));
    }

    return Py_BuildValue("ON", Py_TYPE(lz), args);
}

static PyMethodDef map_methods[] = {
    {"__reduce__", _PyCFunction_CAST(map_reduce), METH_NOARGS, reduce_doc},
    {NULL,           NULL}           /* sentinel */
};


PyDoc_STRVAR(map_doc,
"map(func, *iterables) --> map object\n\
\n\
Make an iterator that computes the function using arguments from\n\
each of the iterables.  Stops when the shortest iterable is exhausted.");

PyTypeObject PyMap_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "map",                              /* tp_name */
    sizeof(mapobject),                  /* tp_basicsize */
    0,                                  /* tp_itemsize */
    /* methods */
    (destructor)map_dealloc,            /* tp_dealloc */
    0,                                  /* tp_vectorcall_offset */
    0,                                  /* tp_getattr */
    0,                                  /* tp_setattr */
    0,                                  /* tp_as_async */
    0,                                  /* tp_repr */
    0,                                  /* tp_as_number */
    0,                                  /* tp_as_sequence */
    0,                                  /* tp_as_mapping */
    0,                                  /* tp_hash */
    0,                                  /* tp_call */
    0,                                  /* tp_str */
    PyObject_GenericGetAttr,            /* tp_getattro */
    0,                                  /* tp_setattro */
    0,                                  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
        Py_TPFLAGS_BASETYPE,            /* tp_flags */
    map_doc,                            /* tp_doc */
    (traverseproc)map_traverse,         /* tp_traverse */
    0,                                  /* tp_clear */
    0,                                  /* tp_richcompare */
    0,                                  /* tp_weaklistoffset */
    PyObject_SelfIter,                  /* tp_iter */
    (iternextfunc)map_next,     /* tp_iternext */
    map_methods,                        /* tp_methods */
    0,                                  /* tp_members */
    0,                                  /* tp_getset */
    0,                                  /* tp_base */
    0,                                  /* tp_dict */
    0,                                  /* tp_descr_get */
    0,                                  /* tp_descr_set */
    0,                                  /* tp_dictoffset */
    0,                                  /* tp_init */
    PyType_GenericAlloc,                /* tp_alloc */
    map_new,                            /* tp_new */
    PyObject_GC_Del,                    /* tp_free */
    .tp_vectorcall = (vectorcallfunc)map_vectorcall
};


/*[clinic input]
next as builtin_next

    iterator: object
    default: object = NULL
    /

Return the next item from the iterator.

If default is given and the iterator is exhausted,
it is returned instead of raising StopIteration.
[clinic start generated code]*/

static PyObject *
builtin_next_impl(PyObject *module, PyObject *iterator,
                  PyObject *default_value)
/*[clinic end generated code: output=a38a94eeb447fef9 input=180f9984f182020f]*/
{
    PyObject *res;

    if (!PyIter_Check(iterator)) {
        PyErr_Format(PyExc_TypeError,
            "'%.200s' object is not an iterator",
            Py_TYPE(iterator)->tp_name);
        return NULL;
    }

    res = (*Py_TYPE(iterator)->tp_iternext)(iterator);
    if (res != NULL) {
        return res;
    } else if (default_value != NULL) {
        if (PyErr_Occurred()) {
            if(!PyErr_ExceptionMatches(PyExc_StopIteration))
                return NULL;
            PyErr_Clear();
        }
        return Py_NewRef(default_value);
    } else if (PyErr_Occurred()) {
        return NULL;
    } else {
        PyErr_SetNone(PyExc_StopIteration);
        return NULL;
    }
}


/*[clinic input]
setattr as builtin_setattr

    obj: object
    name: object
    value: object
    /

Sets the named attribute on the given object to the specified value.

setattr(x, 'y', v) is equivalent to ``x.y = v``
[clinic start generated code]*/

static PyObject *
builtin_setattr_impl(PyObject *module, PyObject *obj, PyObject *name,
                     PyObject *value)
/*[clinic end generated code: output=dc2ce1d1add9acb4 input=5e26417f2e8598d4]*/
{
    if (PyObject_SetAttr(obj, name, value) != 0)
        return NULL;
    Py_RETURN_NONE;
}


/*[clinic input]
delattr as builtin_delattr

    obj: object
    name: object
    /

Deletes the named attribute from the given object.

delattr(x, 'y') is equivalent to ``del x.y``
[clinic start generated code]*/

static PyObject *
builtin_delattr_impl(PyObject *module, PyObject *obj, PyObject *name)
/*[clinic end generated code: output=85134bc58dff79fa input=164865623abe7216]*/
{
    if (PyObject_SetAttr(obj, name, (PyObject *)NULL) != 0)
        return NULL;
    Py_RETURN_NONE;
}


/*[clinic input]
hash as builtin_hash

    obj: object
    /

Return the hash value for the given object.

Two objects that compare equal must also have the same hash value, but the
reverse is not necessarily true.
[clinic start generated code]*/

static PyObject *
builtin_hash(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=237668e9d7688db7 input=58c48be822bf9c54]*/
{
    Py_hash_t x;

    x = PyObject_Hash(obj);
    if (x == -1)
        return NULL;
    return PyLong_FromSsize_t(x);
}


/*[clinic input]
hex as builtin_hex

    number: object
    /

Return the hexadecimal representation of an integer.

   >>> hex(12648430)
   '0xc0ffee'
[clinic start generated code]*/

static PyObject *
builtin_hex(PyObject *module, PyObject *number)
/*[clinic end generated code: output=e46b612169099408 input=e645aff5fc7d540e]*/
{
    return PyNumber_ToBase(number, 16);
}


/*[clinic input]
iter as builtin_iter

    object: object
    sentinel: object = NULL
    /

Get an iterator from an object.

In the first form, the argument must supply its own iterator, or be a sequence.
In the second form, the callable is called until it returns the sentinel.
[clinic start generated code]*/

static PyObject *
builtin_iter_impl(PyObject *module, PyObject *object, PyObject *sentinel)
/*[clinic end generated code: output=12cf64203c195a94 input=a5d64d9d81880ba6]*/
{
    if (sentinel == NULL)
        return PyObject_GetIter(object);
    if (!PyCallable_Check(object)) {
        PyErr_SetString(PyExc_TypeError,
                        "iter(object, sentinel): object must be callable");
        return NULL;
    }
    return PyCallIter_New(object, sentinel);
}


/*[clinic input]
aiter as builtin_aiter

    async_iterable: object
    /

Return an AsyncIterator for an AsyncIterable object.
[clinic start generated code]*/

static PyObject *
builtin_aiter(PyObject *module, PyObject *async_iterable)
/*[clinic end generated code: output=1bae108d86f7960e input=473993d0cacc7d23]*/
{
    return PyObject_GetAIter(async_iterable);
}

PyObject *PyAnextAwaitable_New(PyObject *, PyObject *);

/*[clinic input]
anext as builtin_anext

    aiterator: object
    default: object = NULL
    /

async anext(aiterator[, default])

Return the next item from the async iterator.  If default is given and the async
iterator is exhausted, it is returned instead of raising StopAsyncIteration.
[clinic start generated code]*/

static PyObject *
builtin_anext_impl(PyObject *module, PyObject *aiterator,
                   PyObject *default_value)
/*[clinic end generated code: output=f02c060c163a81fa input=8f63f4f78590bb4c]*/
{
    PyTypeObject *t;
    PyObject *awaitable;

    t = Py_TYPE(aiterator);
    if (t->tp_as_async == NULL || t->tp_as_async->am_anext == NULL) {
        PyErr_Format(PyExc_TypeError,
            "'%.200s' object is not an async iterator",
            t->tp_name);
        return NULL;
    }

    awaitable = (*t->tp_as_async->am_anext)(aiterator);
    if (default_value == NULL) {
        return awaitable;
    }

    PyObject* new_awaitable = PyAnextAwaitable_New(
            awaitable, default_value);
    Py_DECREF(awaitable);
    return new_awaitable;
}


/*[clinic input]
len as builtin_len

    obj: object
    /

Return the number of items in a container.
[clinic start generated code]*/

static PyObject *
builtin_len(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=fa7a270d314dfb6c input=bc55598da9e9c9b5]*/
{
    Py_ssize_t res;

    res = PyObject_Size(obj);
    if (res < 0) {
        assert(PyErr_Occurred());
        return NULL;
    }
    return PyLong_FromSsize_t(res);
}


/*[clinic input]
locals as builtin_locals

Return a dictionary containing the current scope's local variables.

NOTE: Whether or not updates to this dictionary will affect name lookups in
the local scope and vice-versa is *implementation dependent* and not
covered by any backwards compatibility guarantees.
[clinic start generated code]*/

static PyObject *
builtin_locals_impl(PyObject *module)
/*[clinic end generated code: output=b46c94015ce11448 input=7874018d478d5c4b]*/
{
    PyObject *d;

    d = PyEval_GetLocals();
    return Py_XNewRef(d);
}


static PyObject *
min_max(PyObject *args, PyObject *kwds, int op)
{
    PyObject *v, *it, *item, *val, *maxitem, *maxval, *keyfunc=NULL;
    PyObject *emptytuple, *defaultval = NULL;
    static char *kwlist[] = {"key", "default", NULL};
    const char *name = op == Py_LT ? "min" : "max";
    const int positional = PyTuple_Size(args) > 1;
    int ret;

    if (positional) {
        v = args;
    }
    else if (!PyArg_UnpackTuple(args, name, 1, 1, &v)) {
        if (PyExceptionClass_Check(PyExc_TypeError)) {
            PyErr_Format(PyExc_TypeError, "%s expected at least 1 argument, got 0", name);
        }
        return NULL;
    }

    emptytuple = PyTuple_New(0);
    if (emptytuple == NULL)
        return NULL;
    ret = PyArg_ParseTupleAndKeywords(emptytuple, kwds,
                                      (op == Py_LT) ? "|$OO:min" : "|$OO:max",
                                      kwlist, &keyfunc, &defaultval);
    Py_DECREF(emptytuple);
    if (!ret)
        return NULL;

    if (positional && defaultval != NULL) {
        PyErr_Format(PyExc_TypeError,
                        "Cannot specify a default for %s() with multiple "
                        "positional arguments", name);
        return NULL;
    }

    it = PyObject_GetIter(v);
    if (it == NULL) {
        return NULL;
    }

    if (keyfunc == Py_None) {
        keyfunc = NULL;
    }

    maxitem = NULL; /* the result */
    maxval = NULL;  /* the value associated with the result */
    while (( item = PyIter_Next(it) )) {
        /* get the value from the key function */
        if (keyfunc != NULL) {
            val = PyObject_CallOneArg(keyfunc, item);
            if (val == NULL)
                goto Fail_it_item;
        }
        /* no key function; the value is the item */
        else {
            val = Py_NewRef(item);
        }

        /* maximum value and item are unset; set them */
        if (maxval == NULL) {
            maxitem = item;
            maxval = val;
        }
        /* maximum value and item are set; update them as necessary */
        else {
            int cmp = PyObject_RichCompareBool(val, maxval, op);
            if (cmp < 0)
                goto Fail_it_item_and_val;
            else if (cmp > 0) {
                Py_DECREF(maxval);
                Py_DECREF(maxitem);
                maxval = val;
                maxitem = item;
            }
            else {
                Py_DECREF(item);
                Py_DECREF(val);
            }
        }
    }
    if (PyErr_Occurred())
        goto Fail_it;
    if (maxval == NULL) {
        assert(maxitem == NULL);
        if (defaultval != NULL) {
            maxitem = Py_NewRef(defaultval);
        } else {
            PyErr_Format(PyExc_ValueError,
                         "%s() iterable argument is empty", name);
        }
    }
    else
        Py_DECREF(maxval);
    Py_DECREF(it);
    return maxitem;

Fail_it_item_and_val:
    Py_DECREF(val);
Fail_it_item:
    Py_DECREF(item);
Fail_it:
    Py_XDECREF(maxval);
    Py_XDECREF(maxitem);
    Py_DECREF(it);
    return NULL;
}

/* AC: cannot convert yet, waiting for *args support */
static PyObject *
builtin_min(PyObject *self, PyObject *args, PyObject *kwds)
{
    return min_max(args, kwds, Py_LT);
}

PyDoc_STRVAR(min_doc,
"min(iterable, *[, default=obj, key=func]) -> value\n\
min(arg1, arg2, *args, *[, key=func]) -> value\n\
\n\
With a single iterable argument, return its smallest item. The\n\
default keyword-only argument specifies an object to return if\n\
the provided iterable is empty.\n\
With two or more arguments, return the smallest argument.");


/* AC: cannot convert yet, waiting for *args support */
static PyObject *
builtin_max(PyObject *self, PyObject *args, PyObject *kwds)
{
    return min_max(args, kwds, Py_GT);
}

PyDoc_STRVAR(max_doc,
"max(iterable, *[, default=obj, key=func]) -> value\n\
max(arg1, arg2, *args, *[, key=func]) -> value\n\
\n\
With a single iterable argument, return its biggest item. The\n\
default keyword-only argument specifies an object to return if\n\
the provided iterable is empty.\n\
With two or more arguments, return the largest argument.");


/*[clinic input]
oct as builtin_oct

    number: object
    /

Return the octal representation of an integer.

   >>> oct(342391)
   '0o1234567'
[clinic start generated code]*/

static PyObject *
builtin_oct(PyObject *module, PyObject *number)
/*[clinic end generated code: output=40a34656b6875352 input=ad6b274af4016c72]*/
{
    return PyNumber_ToBase(number, 8);
}


/*[clinic input]
ord as builtin_ord

    c: object
    /

Return the Unicode code point for a one-character string.
[clinic start generated code]*/

static PyObject *
builtin_ord(PyObject *module, PyObject *c)
/*[clinic end generated code: output=4fa5e87a323bae71 input=3064e5d6203ad012]*/
{
    long ord;
    Py_ssize_t size;

    if (PyBytes_Check(c)) {
        size = PyBytes_GET_SIZE(c);
        if (size == 1) {
            ord = (long)((unsigned char)*PyBytes_AS_STRING(c));
            return PyLong_FromLong(ord);
        }
    }
    else if (PyUnicode_Check(c)) {
        size = PyUnicode_GET_LENGTH(c);
        if (size == 1) {
            ord = (long)PyUnicode_READ_CHAR(c, 0);
            return PyLong_FromLong(ord);
        }
    }
    else if (PyByteArray_Check(c)) {
        /* XXX Hopefully this is temporary */
        size = PyByteArray_GET_SIZE(c);
        if (size == 1) {
            ord = (long)((unsigned char)*PyByteArray_AS_STRING(c));
            return PyLong_FromLong(ord);
        }
    }
    else {
        PyErr_Format(PyExc_TypeError,
                     "ord() expected string of length 1, but " \
                     "%.200s found", Py_TYPE(c)->tp_name);
        return NULL;
    }

    PyErr_Format(PyExc_TypeError,
                 "ord() expected a character, "
                 "but string of length %zd found",
                 size);
    return NULL;
}


/*[clinic input]
pow as builtin_pow

    base: object
    exp: object
    mod: object = None

Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments

Some types, such as ints, are able to use a more efficient algorithm when
invoked using the three argument form.
[clinic start generated code]*/

static PyObject *
builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp,
                 PyObject *mod)
/*[clinic end generated code: output=3ca1538221bbf15f input=435dbd48a12efb23]*/
{
    return PyNumber_Power(base, exp, mod);
}

/*[clinic input]
print as builtin_print

    *args: object
    sep: object(c_default="Py_None") = ' '
        string inserted between values, default a space.
    end: object(c_default="Py_None") = '\n'
        string appended after the last value, default a newline.
    file: object = None
        a file-like object (stream); defaults to the current sys.stdout.
    flush: bool = False
        whether to forcibly flush the stream.

Prints the values to a stream, or to sys.stdout by default.

[clinic start generated code]*/

static PyObject *
builtin_print_impl(PyObject *module, PyObject *args, PyObject *sep,
                   PyObject *end, PyObject *file, int flush)
/*[clinic end generated code: output=3cfc0940f5bc237b input=c143c575d24fe665]*/
{
    int i, err;

    if (file == Py_None) {
        PyThreadState *tstate = _PyThreadState_GET();
        file = _PySys_GetAttr(tstate, &_Py_ID(stdout));
        if (file == NULL) {
            PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
            return NULL;
        }

        /* sys.stdout may be None when FILE* stdout isn't connected */
        if (file == Py_None) {
            Py_RETURN_NONE;
        }
    }

    if (sep == Py_None) {
        sep = NULL;
    }
    else if (sep && !PyUnicode_Check(sep)) {
        PyErr_Format(PyExc_TypeError,
                     "sep must be None or a string, not %.200s",
                     Py_TYPE(sep)->tp_name);
        return NULL;
    }
    if (end == Py_None) {
        end = NULL;
    }
    else if (end && !PyUnicode_Check(end)) {
        PyErr_Format(PyExc_TypeError,
                     "end must be None or a string, not %.200s",
                     Py_TYPE(end)->tp_name);
        return NULL;
    }

    for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
        if (i > 0) {
            if (sep == NULL) {
                err = PyFile_WriteString(" ", file);
            }
            else {
                err = PyFile_WriteObject(sep, file, Py_PRINT_RAW);
            }
            if (err) {
                return NULL;
            }
        }
        err = PyFile_WriteObject(PyTuple_GET_ITEM(args, i), file, Py_PRINT_RAW);
        if (err) {
            return NULL;
        }
    }

    if (end == NULL) {
        err = PyFile_WriteString("\n", file);
    }
    else {
        err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
    }
    if (err) {
        return NULL;
    }

    if (flush) {
        PyObject *tmp = PyObject_CallMethodNoArgs(file, &_Py_ID(flush));
        if (tmp == NULL) {
            return NULL;
        }
        Py_DECREF(tmp);
    }

    Py_RETURN_NONE;
}


/*[clinic input]
input as builtin_input

    prompt: object(c_default="NULL") = ""
    /

Read a string from standard input.  The trailing newline is stripped.

The prompt string, if given, is printed to standard output without a
trailing newline before reading input.

If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
On *nix systems, readline is used if available.
[clinic start generated code]*/

static PyObject *
builtin_input_impl(PyObject *module, PyObject *prompt)
/*[clinic end generated code: output=83db5a191e7a0d60 input=159c46d4ae40977e]*/
{
    PyThreadState *tstate = _PyThreadState_GET();
    PyObject *fin = _PySys_GetAttr(
        tstate, &_Py_ID(stdin));
    PyObject *fout = _PySys_GetAttr(
        tstate, &_Py_ID(stdout));
    PyObject *ferr = _PySys_GetAttr(
        tstate, &_Py_ID(stderr));
    PyObject *tmp;
    long fd;
    int tty;

    /* Check that stdin/out/err are intact */
    if (fin == NULL || fin == Py_None) {
        PyErr_SetString(PyExc_RuntimeError,
                        "input(): lost sys.stdin");
        return NULL;
    }
    if (fout == NULL || fout == Py_None) {
        PyErr_SetString(PyExc_RuntimeError,
                        "input(): lost sys.stdout");
        return NULL;
    }
    if (ferr == NULL || ferr == Py_None) {
        PyErr_SetString(PyExc_RuntimeError,
                        "input(): lost sys.stderr");
        return NULL;
    }

    if (PySys_Audit("builtins.input", "O", prompt ? prompt : Py_None) < 0) {
        return NULL;
    }

    /* First of all, flush stderr */
    tmp = PyObject_CallMethodNoArgs(ferr, &_Py_ID(flush));
    if (tmp == NULL)
        PyErr_Clear();
    else
        Py_DECREF(tmp);

    /* We should only use (GNU) readline if Python's sys.stdin and
       sys.stdout are the same as C's stdin and stdout, because we
       need to pass it those. */
    tmp = PyObject_CallMethodNoArgs(fin, &_Py_ID(fileno));
    if (tmp == NULL) {
        PyErr_Clear();
        tty = 0;
    }
    else {
        fd = PyLong_AsLong(tmp);
        Py_DECREF(tmp);
        if (fd < 0 && PyErr_Occurred())
            return NULL;
        tty = fd == fileno(stdin) && isatty(fd);
    }
    if (tty) {
        tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(fileno));
        if (tmp == NULL) {
            PyErr_Clear();
            tty = 0;
        }
        else {
            fd = PyLong_AsLong(tmp);
            Py_DECREF(tmp);
            if (fd < 0 && PyErr_Occurred())
                return NULL;
            tty = fd == fileno(stdout) && isatty(fd);
        }
    }

    /* If we're interactive, use (GNU) readline */
    if (tty) {
        PyObject *po = NULL;
        const char *promptstr;
        char *s = NULL;
        PyObject *stdin_encoding = NULL, *stdin_errors = NULL;
        PyObject *stdout_encoding = NULL, *stdout_errors = NULL;
        const char *stdin_encoding_str, *stdin_errors_str;
        PyObject *result;
        size_t len;

        /* stdin is a text stream, so it must have an encoding. */
        stdin_encoding = PyObject_GetAttr(fin, &_Py_ID(encoding));
        stdin_errors = PyObject_GetAttr(fin, &_Py_ID(errors));
        if (!stdin_encoding || !stdin_errors ||
                !PyUnicode_Check(stdin_encoding) ||
                !PyUnicode_Check(stdin_errors)) {
            tty = 0;
            goto _readline_errors;
        }
        stdin_encoding_str = PyUnicode_AsUTF8(stdin_encoding);
        stdin_errors_str = PyUnicode_AsUTF8(stdin_errors);
        if (!stdin_encoding_str || !stdin_errors_str)
            goto _readline_errors;
        tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(flush));
        if (tmp == NULL)
            PyErr_Clear();
        else
            Py_DECREF(tmp);
        if (prompt != NULL) {
            /* We have a prompt, encode it as stdout would */
            const char *stdout_encoding_str, *stdout_errors_str;
            PyObject *stringpo;
            stdout_encoding = PyObject_GetAttr(fout, &_Py_ID(encoding));
            stdout_errors = PyObject_GetAttr(fout, &_Py_ID(errors));
            if (!stdout_encoding || !stdout_errors ||
                    !PyUnicode_Check(stdout_encoding) ||
                    !PyUnicode_Check(stdout_errors)) {
                tty = 0;
                goto _readline_errors;
            }
            stdout_encoding_str = PyUnicode_AsUTF8(stdout_encoding);
            stdout_errors_str = PyUnicode_AsUTF8(stdout_errors);
            if (!stdout_encoding_str || !stdout_errors_str)
                goto _readline_errors;
            stringpo = PyObject_Str(prompt);
            if (stringpo == NULL)
                goto _readline_errors;
            po = PyUnicode_AsEncodedString(stringpo,
                stdout_encoding_str, stdout_errors_str);
            Py_CLEAR(stdout_encoding);
            Py_CLEAR(stdout_errors);
            Py_CLEAR(stringpo);
            if (po == NULL)
                goto _readline_errors;
            assert(PyBytes_Check(po));
            promptstr = PyBytes_AS_STRING(po);
        }
        else {
            po = NULL;
            promptstr = "";
        }
        s = PyOS_Readline(stdin, stdout, promptstr);
        if (s == NULL) {
            PyErr_CheckSignals();
            if (!PyErr_Occurred())
                PyErr_SetNone(PyExc_KeyboardInterrupt);
            goto _readline_errors;
        }

        len = strlen(s);
        if (len == 0) {
            PyErr_SetNone(PyExc_EOFError);
            result = NULL;
        }
        else {
            if (len > PY_SSIZE_T_MAX) {
                PyErr_SetString(PyExc_OverflowError,
                                "input: input too long");
                result = NULL;
            }
            else {
                len--;   /* strip trailing '\n' */
                if (len != 0 && s[len-1] == '\r')
                    len--;   /* strip trailing '\r' */
                result = PyUnicode_Decode(s, len, stdin_encoding_str,
                                                  stdin_errors_str);
            }
        }
        Py_DECREF(stdin_encoding);
        Py_DECREF(stdin_errors);
        Py_XDECREF(po);
        PyMem_Free(s);

        if (result != NULL) {
            if (PySys_Audit("builtins.input/result", "O", result) < 0) {
                return NULL;
            }
        }

        return result;

    _readline_errors:
        Py_XDECREF(stdin_encoding);
        Py_XDECREF(stdout_encoding);
        Py_XDECREF(stdin_errors);
        Py_XDECREF(stdout_errors);
        Py_XDECREF(po);
        if (tty)
            return NULL;

        PyErr_Clear();
    }

    /* Fallback if we're not interactive */
    if (prompt != NULL) {
        if (PyFile_WriteObject(prompt, fout, Py_PRINT_RAW) != 0)
            return NULL;
    }
    tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(flush));
    if (tmp == NULL)
        PyErr_Clear();
    else
        Py_DECREF(tmp);
    return PyFile_GetLine(fin, -1);
}


/*[clinic input]
repr as builtin_repr

    obj: object
    /

Return the canonical string representation of the object.

For many object types, including most builtins, eval(repr(obj)) == obj.
[clinic start generated code]*/

static PyObject *
builtin_repr(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=7ed3778c44fd0194 input=1c9e6d66d3e3be04]*/
{
    return PyObject_Repr(obj);
}


/*[clinic input]
round as builtin_round

    number: object
    ndigits: object = None

Round a number to a given precision in decimal digits.

The return value is an integer if ndigits is omitted or None.  Otherwise
the return value has the same type as the number.  ndigits may be negative.
[clinic start generated code]*/

static PyObject *
builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits)
/*[clinic end generated code: output=ff0d9dd176c02ede input=275678471d7aca15]*/
{
    PyObject *round, *result;

    if (!_PyType_IsReady(Py_TYPE(number))) {
        if (PyType_Ready(Py_TYPE(number)) < 0)
            return NULL;
    }

    round = _PyObject_LookupSpecial(number, &_Py_ID(__round__));
    if (round == NULL) {
        if (!PyErr_Occurred())
            PyErr_Format(PyExc_TypeError,
                         "type %.100s doesn't define __round__ method",
                         Py_TYPE(number)->tp_name);
        return NULL;
    }

    if (ndigits == Py_None)
        result = _PyObject_CallNoArgs(round);
    else
        result = PyObject_CallOneArg(round, ndigits);
    Py_DECREF(round);
    return result;
}


/*AC: we need to keep the kwds dict intact to easily call into the
 * list.sort method, which isn't currently supported in AC. So we just use
 * the initially generated signature with a custom implementation.
 */
/* [disabled clinic input]
sorted as builtin_sorted

    iterable as seq: object
    key as keyfunc: object = None
    reverse: object = False

Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
[end disabled clinic input]*/

PyDoc_STRVAR(builtin_sorted__doc__,
"sorted($module, iterable, /, *, key=None, reverse=False)\n"
"--\n"
"\n"
"Return a new list containing all items from the iterable in ascending order.\n"
"\n"
"A custom key function can be supplied to customize the sort order, and the\n"
"reverse flag can be set to request the result in descending order.");

#define BUILTIN_SORTED_METHODDEF    \
    {"sorted", _PyCFunction_CAST(builtin_sorted), METH_FASTCALL | METH_KEYWORDS, builtin_sorted__doc__},

static PyObject *
builtin_sorted(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *newlist, *v, *seq, *callable;

    /* Keyword arguments are passed through list.sort() which will check
       them. */
    if (!_PyArg_UnpackStack(args, nargs, "sorted", 1, 1, &seq))
        return NULL;

    newlist = PySequence_List(seq);
    if (newlist == NULL)
        return NULL;

    callable = PyObject_GetAttr(newlist, &_Py_ID(sort));
    if (callable == NULL) {
        Py_DECREF(newlist);
        return NULL;
    }

    assert(nargs >= 1);
    v = PyObject_Vectorcall(callable, args + 1, nargs - 1, kwnames);
    Py_DECREF(callable);
    if (v == NULL) {
        Py_DECREF(newlist);
        return NULL;
    }
    Py_DECREF(v);
    return newlist;
}


/*[clinic input]
vars as builtin_vars

    object: object = NULL
    /

Show vars.

Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.
[clinic start generated code]*/

static PyObject *
builtin_vars_impl(PyObject *module, PyObject *object)
/*[clinic end generated code: output=840a7f64007a3e0a input=80cbdef9182c4ba3]*/
{
    PyObject *d;

    if (object == NULL) {
        d = Py_XNewRef(PyEval_GetLocals());
    }
    else {
        if (_PyObject_LookupAttr(object, &_Py_ID(__dict__), &d) == 0) {
            PyErr_SetString(PyExc_TypeError,
                "vars() argument must have __dict__ attribute");
        }
    }
    return d;
}


/*[clinic input]
sum as builtin_sum

    iterable: object
    /
    start: object(c_default="NULL") = 0

Return the sum of a 'start' value (default: 0) plus an iterable of numbers

When the iterable is empty, return the start value.
This function is intended specifically for use with numeric values and may
reject non-numeric types.
[clinic start generated code]*/

static PyObject *
builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start)
/*[clinic end generated code: output=df758cec7d1d302f input=162b50765250d222]*/
{
    PyObject *result = start;
    PyObject *temp, *item, *iter;

    iter = PyObject_GetIter(iterable);
    if (iter == NULL)
        return NULL;

    if (result == NULL) {
        result = PyLong_FromLong(0);
        if (result == NULL) {
            Py_DECREF(iter);
            return NULL;
        }
    } else {
        /* reject string values for 'start' parameter */
        if (PyUnicode_Check(result)) {
            PyErr_SetString(PyExc_TypeError,
                "sum() can't sum strings [use ''.join(seq) instead]");
            Py_DECREF(iter);
            return NULL;
        }
        if (PyBytes_Check(result)) {
            PyErr_SetString(PyExc_TypeError,
                "sum() can't sum bytes [use b''.join(seq) instead]");
            Py_DECREF(iter);
            return NULL;
        }
        if (PyByteArray_Check(result)) {
            PyErr_SetString(PyExc_TypeError,
                "sum() can't sum bytearray [use b''.join(seq) instead]");
            Py_DECREF(iter);
            return NULL;
        }
        Py_INCREF(result);
    }

#ifndef SLOW_SUM
    /* Fast addition by keeping temporary sums in C instead of new Python objects.
       Assumes all inputs are the same type.  If the assumption fails, default
       to the more general routine.
    */
    if (PyLong_CheckExact(result)) {
        int overflow;
        Py_ssize_t i_result = PyLong_AsLongAndOverflow(result, &overflow);
        /* If this already overflowed, don't even enter the loop. */
        if (overflow == 0) {
            Py_SETREF(result, NULL);
        }
        while(result == NULL) {
            item = PyIter_Next(iter);
            if (item == NULL) {
                Py_DECREF(iter);
                if (PyErr_Occurred())
                    return NULL;
                return PyLong_FromSsize_t(i_result);
            }
            if (PyLong_CheckExact(item) || PyBool_Check(item)) {
                Py_ssize_t b;
                overflow = 0;
                /* Single digits are common, fast, and cannot overflow on unpacking. */
                if (_PyLong_IsCompact((PyLongObject *)item)) {
                    b = _PyLong_CompactValue((PyLongObject *)item);
                }
                else {
                    b = PyLong_AsLongAndOverflow(item, &overflow);
                }
                if (overflow == 0 &&
                    (i_result >= 0 ? (b <= LONG_MAX - i_result)
                                   : (b >= LONG_MIN - i_result)))
                {
                    i_result += b;
                    Py_DECREF(item);
                    continue;
                }
            }
            /* Either overflowed or is not an int. Restore real objects and process normally */
            result = PyLong_FromSsize_t(i_result);
            if (result == NULL) {
                Py_DECREF(item);
                Py_DECREF(iter);
                return NULL;
            }
            temp = PyNumber_Add(result, item);
            Py_DECREF(result);
            Py_DECREF(item);
            result = temp;
            if (result == NULL) {
                Py_DECREF(iter);
                return NULL;
            }
        }
    }

    if (PyFloat_CheckExact(result)) {
        double f_result = PyFloat_AS_DOUBLE(result);
        double c = 0.0;
        Py_SETREF(result, NULL);
        while(result == NULL) {
            item = PyIter_Next(iter);
            if (item == NULL) {
                Py_DECREF(iter);
                if (PyErr_Occurred())
                    return NULL;
                /* Avoid losing the sign on a negative result,
                   and don't let adding the compensation convert
                   an infinite or overflowed sum to a NaN. */
                if (c && Py_IS_FINITE(c)) {
                    f_result += c;
                }
                return PyFloat_FromDouble(f_result);
            }
            if (PyFloat_CheckExact(item)) {
                // Improved Kahan–Babuška algorithm by Arnold Neumaier
                // https://www.mat.univie.ac.at/~neum/scan/01.pdf
                double x = PyFloat_AS_DOUBLE(item);
                double t = f_result + x;
                if (fabs(f_result) >= fabs(x)) {
                    c += (f_result - t) + x;
                } else {
                    c += (x - t) + f_result;
                }
                f_result = t;
                _Py_DECREF_SPECIALIZED(item, _PyFloat_ExactDealloc);
                continue;
            }
            if (PyLong_Check(item)) {
                long value;
                int overflow;
                value = PyLong_AsLongAndOverflow(item, &overflow);
                if (!overflow) {
                    f_result += (double)value;
                    Py_DECREF(item);
                    continue;
                }
            }
            if (c && Py_IS_FINITE(c)) {
                f_result += c;
            }
            result = PyFloat_FromDouble(f_result);
            if (result == NULL) {
                Py_DECREF(item);
                Py_DECREF(iter);
                return NULL;
            }
            temp = PyNumber_Add(result, item);
            Py_DECREF(result);
            Py_DECREF(item);
            result = temp;
            if (result == NULL) {
                Py_DECREF(iter);
                return NULL;
            }
        }
    }
#endif

    for(;;) {
        item = PyIter_Next(iter);
        if (item == NULL) {
            /* error, or end-of-sequence */
            if (PyErr_Occurred()) {
                Py_SETREF(result, NULL);
            }
            break;
        }
        /* It's tempting to use PyNumber_InPlaceAdd instead of
           PyNumber_Add here, to avoid quadratic running time
           when doing 'sum(list_of_lists, [])'.  However, this
           would produce a change in behaviour: a snippet like

             empty = []
             sum([[x] for x in range(10)], empty)

           would change the value of empty. In fact, using
           in-place addition rather that binary addition for
           any of the steps introduces subtle behavior changes:

           https://bugs.python.org/issue18305 */
        temp = PyNumber_Add(result, item);
        Py_DECREF(result);
        Py_DECREF(item);
        result = temp;
        if (result == NULL)
            break;
    }
    Py_DECREF(iter);
    return result;
}


/*[clinic input]
isinstance as builtin_isinstance

    obj: object
    class_or_tuple: object
    /

Return whether an object is an instance of a class or of a subclass thereof.

A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
or ...`` etc.
[clinic start generated code]*/

static PyObject *
builtin_isinstance_impl(PyObject *module, PyObject *obj,
                        PyObject *class_or_tuple)
/*[clinic end generated code: output=6faf01472c13b003 input=ffa743db1daf7549]*/
{
    int retval;

    retval = PyObject_IsInstance(obj, class_or_tuple);
    if (retval < 0)
        return NULL;
    return PyBool_FromLong(retval);
}


/*[clinic input]
issubclass as builtin_issubclass

    cls: object
    class_or_tuple: object
    /

Return whether 'cls' is derived from another class or is the same class.

A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
check against. This is equivalent
Download .txt
gitextract_msw6v1wo/

├── Asdl.c
├── Asm_Trampoline.S
├── Assemble.c
├── Ast.c
├── Ast_Opt.c
├── Ast_Unparse.c
├── BltinModule.c
├── Bootstrap_Hash.c
├── ByteCodes.c
├── CeVal.c
├── Ceval_Gil.c
├── Ceval_Macros.h
├── Clinic/
│   ├── Python-tokenize.c.h
│   ├── _warnings.c.h
│   ├── bltinmodule.c.h
│   ├── context.c.h
│   ├── import.c.h
│   ├── instrumentation.c.h
│   ├── marshal.c.h
│   ├── sysmodule.c.h
│   └── traceback.c.h
├── CodeCS.c
├── Compile.c
├── Condvar.h
├── Context.c
├── Dtoa.c
├── Dup2.c
├── Dynamic_Annotations.c
├── Dynload_Hpux.c
├── Dynload_Shlib.c
├── Dynload_Stub.c
├── Dynload_Win.c
├── Emscripten_Signal.c
├── Errors.c
├── Fileutils.c
├── Flowgraph.c
├── Formatter_Unicode.c
├── Frame.c
├── Frozen.c
├── FrozenMain.c
├── Future.c
├── Game/
│   ├── CMakeLists.txt
│   ├── graphics.asm
│   ├── linked_list.asm
│   ├── main.asm
│   ├── memory.asm
│   └── utils.asm
├── Game I/
│   ├── CMakeLists.txt
│   ├── c_key_event.h
│   ├── c_list.c
│   ├── c_list.h
│   ├── c_rectangle.c
│   ├── c_rectangle.h
│   ├── c_result.h
│   ├── c_vector2.c
│   ├── c_vector2.h
│   ├── c_window.c
│   ├── c_window.h
│   └── main.c
├── Game II/
│   ├── CMakeLists.txt
│   ├── colour.cpp
│   ├── colour.h
│   ├── entity.cpp
│   ├── entity.h
│   ├── key_event.h
│   ├── main.cpp
│   ├── rectangle.cpp
│   ├── rectangle.h
│   ├── vector2.cpp
│   ├── vector2.h
│   ├── window.cpp
│   └── window.h
├── GeTargs.c
├── Generated_Cases.c.h
├── GetArgs.c
├── GetCompiler.c
├── GetCopyRight.c
├── GetCopyright.c
├── GetOpt.c
├── GetPlatForm.c
├── GetVersion.c
├── Get_Compiler.c
├── Get_Opt.c
├── Get_Plat_Form.c
├── Getversion.c
├── Hamt.c
├── HashTable.c
├── ImPort.c
├── ImPortdl.c
├── ImPortdl.h
├── InTrinSics.c
├── InitConfig.c
├── InstruMenTation.c
├── InstruMentation.c
├── Legacy_Tracing.c
├── MakeOpCodeTargets.py
├── MarShal.c
├── ModSupport.c
├── MySnPrintf.c
├── MyStrtoul.c
├── OpCode_MetaData.h
├── OpCode_Targets.h
├── OptiMizer.c
├── PathConfig.c
├── Perf_Trampoline.c
├── PreConfig.c
├── PyArena.c
├── PyCtype.c
├── PyFpc.c
├── PyHash.c
├── PyLifeCycle.c
├── PyMath.c
├── PyState.c
├── PyStrcmp.c
├── PyStrhex.c
├── PyStrtod.c
├── PyTime.c
├── Python-AST.c
├── Python-Tokenize.c
├── PythonRun.c
├── Specialize.c
├── Stdlib_Module_Names.h
├── StrucMember.c
├── Suggestions.c
├── SyMTable.c
├── SySModule.c
├── Thread.c
├── Thread_NT.h
├── Thread_Pthread.h
├── Thread_Pthread_Dtubs.h
├── TraceBack.c
└── TraceMalloc.c
Download .txt
SYMBOL INDEX (3265 symbols across 112 files)

FILE: Assemble.c
  type _PyCompilerSrcLocation (line 23) | typedef _PyCompilerSrcLocation location;
  type _PyCompile_Instruction (line 24) | typedef _PyCompile_Instruction instruction;
  type _PyCompile_InstructionSequence (line 25) | typedef _PyCompile_InstructionSequence instr_sequence;
  function same_location (line 27) | static inline bool
  type assembler (line 36) | struct assembler {
  function assemble_init (line 47) | static int
  function assemble_free (line 75) | static void
  function write_except_byte (line 83) | static inline void
  function assemble_emit_exception_table_item (line 91) | static void
  function assemble_emit_exception_table_entry (line 118) | static int
  function assemble_exception_table (line 142) | static int
  function write_location_byte (line 174) | static void
  type assembler (line 183) | struct assembler
  function write_location_first_byte (line 189) | static void
  function write_location_varint (line 196) | static void
  function write_location_signed_varint (line 204) | static void
  function write_location_info_short_form (line 211) | static void
  function write_location_info_oneline_form (line 224) | static void
  function write_location_info_long_form (line 236) | static void
  function write_location_info_none (line 248) | static void
  function write_location_info_no_column (line 254) | static void
  function write_location_info_entry (line 264) | static int
  function assemble_emit_location (line 304) | static int
  function assemble_location_info (line 317) | static int
  function write_instr (line 337) | static void
  function assemble_emit_instr (line 381) | static int
  function assemble_emit (line 400) | static int
  function PyObject (line 426) | static PyObject *
  function compute_localsplus_info (line 448) | static void
  function PyCodeObject (line 496) | static PyCodeObject *
  function PyCodeObject (line 588) | PyCodeObject *

FILE: Ast.c
  type validator (line 12) | struct validator {
  type validator (line 17) | struct validator
  type validator (line 18) | struct validator
  type validator (line 19) | struct validator
  type validator (line 20) | struct validator
  type validator (line 22) | struct validator
  type validator (line 23) | struct validator
  type validator (line 24) | struct validator
  type validator (line 25) | struct validator
  function validate_name (line 48) | static int
  function validate_comprehension (line 68) | static int
  function validate_keywords (line 86) | static int
  function validate_args (line 96) | static int
  function validate_arguments (line 124) | static int
  function validate_constant (line 153) | static int
  function validate_expr (line 210) | static int
  function ensure_literal_number (line 404) | static int
  function ensure_literal_negative (line 414) | static int
  function ensure_literal_complex (line 431) | static int
  function validate_pattern_match_value (line 471) | static int
  function validate_capture (line 525) | static int
  function validate_pattern (line 536) | static int
  function _validate_nonempty_seq (line 692) | static int
  function validate_assignlist (line 702) | static int
  function validate_body (line 710) | static int
  function validate_stmt (line 717) | static int
  function validate_stmts (line 943) | static int
  function validate_exprs (line 962) | static int
  function validate_patterns (line 982) | static int
  function validate_typeparam (line 995) | static int
  function validate_type_params (line 1016) | static int
  function _PyAST_Validate (line 1034) | int
  function PyObject (line 1086) | PyObject *

FILE: Ast_Opt.c
  type _PyASTOptimizeState (line 9) | typedef struct {
  function make_const (line 18) | static int
  function has_starred (line 42) | static int
  function PyObject (line 56) | static PyObject*
  function fold_unaryop (line 65) | static int
  function Py_ssize_t (line 133) | static Py_ssize_t
  function PyObject (line 161) | static PyObject *
  function PyObject (line 209) | static PyObject *
  function PyObject (line 228) | static PyObject *
  function PyObject (line 247) | static PyObject *
  function expr_ty (line 258) | static expr_ty
  function simple_format_arg_parse (line 304) | static int
  function expr_ty (line 364) | static expr_ty
  function optimize_format (line 407) | static int
  function fold_binop (line 459) | static int
  function PyObject (line 532) | static PyObject*
  function fold_tuple (line 555) | static int
  function fold_subscr (line 567) | static int
  function fold_iter (line 592) | static int
  function fold_compare (line 621) | static int
  function astfold_body (line 674) | static int
  function astfold_mod (line 697) | static int
  function astfold_expr (line 719) | static int
  function astfold_keyword (line 842) | static int
  function astfold_comprehension (line 849) | static int
  function astfold_arguments (line 860) | static int
  function astfold_arg (line 873) | static int
  function astfold_stmt (line 882) | static int
  function astfold_excepthandler (line 1017) | static int
  function astfold_withitem (line 1031) | static int
  function astfold_pattern (line 1039) | static int
  function astfold_match_case (line 1085) | static int
  function astfold_type_param (line 1094) | static int
  function _PyAST_Optimize (line 1116) | int

FILE: Ast_Unparse.c
  function append_charp (line 34) | static int
  function append_repr (line 73) | static int
  function append_ast_boolop (line 126) | static int
  function append_ast_binop (line 148) | static int
  function append_ast_unaryop (line 183) | static int
  function append_ast_arg (line 207) | static int
  function append_ast_args (line 220) | static int
  function append_ast_lambda (line 286) | static int
  function append_ast_ifexp (line 300) | static int
  function append_ast_dict (line 313) | static int
  function append_ast_set (line 339) | static int
  function append_ast_list (line 354) | static int
  function append_ast_tuple (line 369) | static int
  function append_ast_comprehension (line 392) | static int
  function append_ast_comprehensions (line 410) | static int
  function append_ast_genexp (line 423) | static int
  function append_ast_listcomp (line 432) | static int
  function append_ast_setcomp (line 441) | static int
  function append_ast_dictcomp (line 450) | static int
  function append_ast_compare (line 461) | static int
  function append_ast_keyword (line 525) | static int
  function append_ast_call (line 543) | static int
  function PyObject (line 578) | static PyObject *
  function append_fstring_unicode (line 592) | static int
  function append_fstring_element (line 605) | static int
  function PyObject (line 624) | static PyObject *
  function append_joinedstr (line 647) | static int
  function append_formattedvalue (line 670) | static int
  function append_ast_constant (line 728) | static int
  function append_ast_attribute (line 750) | static int
  function append_ast_slice (line 770) | static int
  function append_ast_subscript (line 790) | static int
  function append_ast_starred (line 799) | static int
  function append_ast_yield (line 807) | static int
  function append_ast_yield_from (line 819) | static int
  function append_ast_await (line 827) | static int
  function append_named_expr (line 837) | static int
  function append_ast_expr (line 848) | static int
  function maybe_init_static_strings (line 921) | static int
  function PyObject (line 935) | static PyObject *
  function PyObject (line 951) | PyObject *

FILE: BltinModule.c
  function PyObject (line 17) | static PyObject*
  function PyObject (line 90) | static PyObject *
  function PyObject (line 270) | static PyObject *
  function PyObject (line 289) | static PyObject *
  function PyObject (line 307) | static PyObject *
  function PyObject (line 356) | static PyObject *
  function PyObject (line 408) | static PyObject *
  function PyObject (line 428) | static PyObject *
  function PyObject (line 448) | static PyObject *
  function PyObject (line 455) | static PyObject *
  type filterobject (line 483) | typedef struct {
  function PyObject (line 489) | static PyObject *
  function PyObject (line 521) | static PyObject *
  function filter_dealloc (line 553) | static void
  function filter_traverse (line 564) | static int
  function PyObject (line 572) | static PyObject *
  function PyObject (line 607) | static PyObject *
  function PyObject (line 689) | static PyObject *
  function PyObject (line 705) | static PyObject *
  function PyObject (line 739) | static PyObject *
  function PyObject (line 863) | static PyObject *
  function PyObject (line 880) | static PyObject *
  function PyObject (line 905) | static PyObject *
  function PyObject (line 998) | static PyObject *
  function PyObject (line 1132) | static PyObject *
  function PyObject (line 1160) | static PyObject *
  function PyObject (line 1183) | static PyObject *
  function PyObject (line 1217) | static PyObject *
  type mapobject (line 1234) | typedef struct {
  function PyObject (line 1240) | static PyObject *
  function PyObject (line 1285) | static PyObject *
  function map_dealloc (line 1326) | static void
  function map_traverse (line 1335) | static int
  function PyObject (line 1343) | static PyObject *
  function PyObject (line 1386) | static PyObject *
  function PyObject (line 1474) | static PyObject *
  function PyObject (line 1520) | static PyObject *
  function PyObject (line 1543) | static PyObject *
  function PyObject (line 1565) | static PyObject *
  function PyObject (line 1590) | static PyObject *
  function PyObject (line 1611) | static PyObject *
  function PyObject (line 1635) | static PyObject *
  function PyObject (line 1657) | static PyObject *
  function PyObject (line 1694) | static PyObject *
  function PyObject (line 1719) | static PyObject *
  function PyObject (line 1730) | static PyObject *
  function PyObject (line 1840) | static PyObject *
  function PyObject (line 1857) | static PyObject *
  function PyObject (line 1885) | static PyObject *
  function PyObject (line 1902) | static PyObject *
  function PyObject (line 1959) | static PyObject *
  function PyObject (line 1984) | static PyObject *
  function PyObject (line 2079) | static PyObject *
  function PyObject (line 2291) | static PyObject *
  function PyObject (line 2311) | static PyObject *
  function PyObject (line 2369) | static PyObject *
  function PyObject (line 2413) | static PyObject *
  function PyObject (line 2446) | static PyObject *
  function PyObject (line 2654) | static PyObject *
  function PyObject (line 2682) | static PyObject *
  type zipobject (line 2695) | typedef struct {
  function PyObject (line 2703) | static PyObject *
  function zip_dealloc (line 2770) | static void
  function zip_traverse (line 2779) | static int
  function PyObject (line 2787) | static PyObject *
  function PyObject (line 2877) | static PyObject *
  function PyObject (line 2889) | static PyObject *
  type PyModuleDef (line 3026) | struct PyModuleDef
  function PyObject (line 3039) | PyObject *

FILE: Bootstrap_Hash.c
  function win32_urandom (line 49) | static int
  function py_getrandom (line 86) | static int
  function py_getentropy (line 207) | static int
  function dev_urandom (line 296) | static int
  function dev_urandom_close (line 394) | static void
  function lcg_urandom (line 414) | static void
  function pyurandom (line 472) | static int
  function _PyOS_URandom (line 526) | int
  function _PyOS_URandomNonblock (line 540) | int
  function PyStatus (line 547) | PyStatus
  function _Py_HashRandomization_Fini (line 587) | void

FILE: ByteCodes.c
  function PyObject (line 67) | static PyObject *

FILE: CeVal.c
  function dump_stack (line 106) | static void
  function lltrace_instruction (line 127) | static void
  function lltrace_resume_frame (line 149) | static void
  function Py_GetRecursionLimit (line 232) | int
  function Py_SetRecursionLimit (line 239) | void
  function _Py_CheckRecursiveCall (line 253) | int
  function PyObject (line 319) | static PyObject*
  function PyObject (line 401) | static PyObject*
  function PyObject (line 425) | static PyObject*
  function PyObject (line 541) | PyObject *
  function PyObject (line 575) | PyObject *
  function PyObject (line 583) | PyObject *
  function _Py_CheckRecursiveCallPy (line 593) | int _Py_CheckRecursiveCallPy(
  function _Py_EnterRecursivePy (line 614) | static inline int _Py_EnterRecursivePy(PyThreadState *tstate) {
  function _Py_LeaveRecursiveCallPy (line 620) | static inline void _Py_LeaveRecursiveCallPy(PyThreadState *tstate)  {
  function format_missing (line 949) | static void
  function missing_arguments (line 1012) | static void
  function too_many_positional (line 1051) | static void
  function positional_only_passed_as_keyword (line 1109) | static int
  function get_exception_handler (line 1191) | static int
  function initialize_locals (line 1241) | static int
  function clear_thread_frame (line 1465) | static void
  function clear_gen_frame (line 1481) | static void
  function _PyEvalFrameClearAndPop (line 1497) | static void
  function _PyInterpreterFrame (line 1509) | static _PyInterpreterFrame *
  function _PyInterpreterFrame (line 1545) | static _PyInterpreterFrame *
  function PyObject (line 1585) | PyObject *
  function PyObject (line 1614) | PyObject *
  function do_raise (line 1689) | static int
  function exception_group_match (line 1785) | static int
  function unpack_iterable (line 1848) | static int
  function do_monitor_exc (line 1941) | static int
  function no_tools_for_event (line 1958) | static inline int
  function monitor_raise (line 1975) | static void
  function monitor_stop_iteration (line 1985) | static int
  function monitor_unwind (line 1995) | static void
  function monitor_handled (line 2007) | static void
  function monitor_throw (line 2018) | static void
  function PyThreadState_EnterTracing (line 2029) | void
  function PyThreadState_LeaveTracing (line 2036) | void
  function PyObject (line 2044) | PyObject*
  function PyEval_SetProfile (line 2060) | void
  function PyEval_SetProfileAllThreads (line 2070) | void
  function PyEval_SetTrace (line 2091) | void
  function PyEval_SetTraceAllThreads (line 2101) | void
  function _PyEval_SetCoroutineOriginTrackingDepth (line 2122) | int
  function _PyEval_GetCoroutineOriginTrackingDepth (line 2135) | int
  function _PyEval_SetAsyncGenFirstiter (line 2142) | int
  function PyObject (line 2155) | PyObject *
  function _PyEval_SetAsyncGenFinalizer (line 2162) | int
  function PyObject (line 2175) | PyObject *
  function _PyInterpreterFrame (line 2182) | _PyInterpreterFrame *
  function PyFrameObject (line 2189) | PyFrameObject *
  function PyObject (line 2203) | PyObject *
  function PyObject (line 2213) | PyObject *
  function PyObject (line 2221) | PyObject *
  function PyObject (line 2235) | PyObject *
  function PyObject (line 2241) | PyObject *
  function PyObject (line 2260) | PyObject *
  function PyEval_MergeCompilerFlags (line 2271) | int
  function _PyEval_SliceIndex (line 2322) | int
  function _PyEval_SliceIndexNotNone (line 2344) | int
  function PyObject (line 2364) | static PyObject *
  function PyObject (line 2406) | static PyObject *
  function check_except_type_valid (line 2485) | static int
  function check_except_star_type_valid (line 2510) | static int
  function check_args_iterable (line 2547) | static int
  function format_kwargs_error (line 2567) | static void
  function format_exc_check_arg (line 2609) | static void
  function format_exc_unbound (line 2638) | static void
  function format_awaitable_error (line 2655) | static void
  function Py_ssize_t (line 2675) | Py_ssize_t
  function Py_EnterRecursiveCall (line 2692) | int Py_EnterRecursiveCall(const char *where)
  function Py_LeaveRecursiveCall (line 2697) | void Py_LeaveRecursiveCall(void)

FILE: Ceval_Gil.c
  function COMPUTE_EVAL_BREAKER (line 62) | static inline void
  function SET_GIL_DROP_REQUEST (line 78) | static inline void
  function RESET_GIL_DROP_REQUEST (line 87) | static inline void
  function SIGNAL_PENDING_CALLS (line 97) | static inline void
  function UNSIGNAL_PENDING_CALLS (line 107) | static inline void
  function SIGNAL_PENDING_SIGNALS (line 117) | static inline void
  function UNSIGNAL_PENDING_SIGNALS (line 133) | static inline void
  function SIGNAL_ASYNC_EXC (line 143) | static inline void
  function UNSIGNAL_ASYNC_EXC (line 152) | static inline void
  function is_tstate_valid (line 163) | static int
  function _gil_initialize (line 223) | static void _gil_initialize(struct _gil_runtime_state *gil)
  function gil_created (line 230) | static int gil_created(struct _gil_runtime_state *gil)
  function create_gil (line 238) | static void create_gil(struct _gil_runtime_state *gil)
  function destroy_gil (line 253) | static void destroy_gil(struct _gil_runtime_state *gil)
  function recreate_gil (line 270) | static void recreate_gil(struct _gil_runtime_state *gil)
  function drop_gil (line 278) | static void
  function tstate_must_exit (line 344) | static inline int
  function take_gil (line 364) | static void
  function _PyEval_SetSwitchInterval (line 488) | void _PyEval_SetSwitchInterval(unsigned long microseconds)
  function _PyEval_GetSwitchInterval (line 496) | unsigned long _PyEval_GetSwitchInterval(void)
  function _PyEval_ThreadsInitialized (line 505) | int
  function PyEval_ThreadsInitialized (line 520) | PyAPI_FUNC(int)
  function current_thread_holds_gil (line 526) | static inline int
  function init_shared_gil (line 535) | static void
  function init_own_gil (line 543) | static void
  function PyStatus (line 553) | PyStatus
  function _PyEval_FiniGIL (line 578) | void
  function PyEval_InitThreads (line 609) | PyAPI_FUNC(void)
  function _PyEval_Fini (line 615) | void
  function PyEval_AcquireLock (line 624) | PyAPI_FUNC(void)
  function PyEval_ReleaseLock (line 634) | PyAPI_FUNC(void)
  function _PyEval_AcquireLock (line 645) | void
  function _PyEval_ReleaseLock (line 652) | void
  function PyEval_AcquireThread (line 662) | void
  function PyEval_ReleaseThread (line 674) | void
  function PyStatus (line 691) | PyStatus
  function _PyEval_SignalAsyncExc (line 718) | void
  function PyThreadState (line 724) | PyThreadState *
  function PyEval_RestoreThread (line 736) | void
  function _PyEval_SignalReceived (line 769) | void
  function _push_pending_call (line 791) | static int
  function _pop_pending_call (line 807) | static void
  function _PyEval_AddPendingCall (line 826) | int
  function Py_AddPendingCall (line 844) | int
  function handle_signals (line 875) | static int
  function make_pending_calls (line 892) | static int
  function _Py_FinishPendingCalls (line 941) | void
  function Py_MakePendingCalls (line 963) | int
  function _PyEval_InitState (line 986) | void
  function _PyEval_FiniState (line 996) | void
  function _Py_HandlePending (line 1008) | int

FILE: Ceval_Macros.h
  function PyObject (line 129) | static inline PyObject *

FILE: Clinic/Python-tokenize.c.h
  function PyObject (line 15) | static PyObject *

FILE: Clinic/_warnings.c.h
  function PyObject (line 39) | static PyObject *
  function PyObject (line 146) | static PyObject *
  function PyObject (line 241) | static PyObject *

FILE: Clinic/bltinmodule.c.h
  function PyObject (line 39) | static PyObject *
  function PyObject (line 201) | static PyObject *
  function PyObject (line 239) | static PyObject *
  function PyObject (line 281) | static PyObject *
  function PyObject (line 409) | static PyObject *
  function PyObject (line 441) | static PyObject *
  function PyObject (line 478) | static PyObject *
  function PyObject (line 526) | static PyObject *
  function PyObject (line 606) | static PyObject *
  function PyObject (line 645) | static PyObject *
  function PyObject (line 665) | static PyObject *
  function PyObject (line 711) | static PyObject *
  function PyObject (line 748) | static PyObject *
  function PyObject (line 782) | static PyObject *
  function PyObject (line 839) | static PyObject *
  function PyObject (line 886) | static PyObject *
  function PyObject (line 933) | static PyObject *
  function PyObject (line 976) | static PyObject *
  function PyObject (line 1050) | static PyObject *
  function PyObject (line 1143) | static PyObject *
  function PyObject (line 1189) | static PyObject *
  function PyObject (line 1254) | static PyObject *
  function PyObject (line 1290) | static PyObject *
  function PyObject (line 1357) | static PyObject *
  function PyObject (line 1392) | static PyObject *

FILE: Clinic/context.c.h
  function PyObject (line 27) | static PyObject *
  function PyObject (line 63) | static PyObject *
  function PyObject (line 81) | static PyObject *
  function PyObject (line 99) | static PyObject *
  function PyObject (line 117) | static PyObject *
  function PyObject (line 141) | static PyObject *

FILE: Clinic/import.c.h
  function PyObject (line 25) | static PyObject *
  function PyObject (line 46) | static PyObject *
  function PyObject (line 66) | static PyObject *
  function PyObject (line 90) | static PyObject *
  function PyObject (line 137) | static PyObject *
  function PyObject (line 155) | static PyObject *
  function PyObject (line 192) | static PyObject *
  function PyObject (line 262) | static PyObject *
  function PyObject (line 300) | static PyObject *
  function PyObject (line 329) | static PyObject *
  function PyObject (line 358) | static PyObject *
  function PyObject (line 387) | static PyObject *
  function PyObject (line 408) | static PyObject *
  function PyObject (line 439) | static PyObject *
  function PyObject (line 469) | static PyObject *
  function PyObject (line 507) | static PyObject *
  function PyObject (line 537) | static PyObject *
  function PyObject (line 564) | static PyObject *

FILE: Clinic/instrumentation.c.h
  function PyObject (line 22) | static PyObject *
  function PyObject (line 54) | static PyObject *
  function PyObject (line 81) | static PyObject *
  function PyObject (line 109) | static PyObject *
  function PyObject (line 146) | static PyObject *
  function PyObject (line 178) | static PyObject *
  function PyObject (line 214) | static PyObject *
  function PyObject (line 252) | static PyObject *
  function PyObject (line 289) | static PyObject *
  function PyObject (line 306) | static PyObject *

FILE: Clinic/marshal.c.h
  function PyObject (line 35) | static PyObject *
  function PyObject (line 101) | static PyObject *
  function PyObject (line 141) | static PyObject *

FILE: Clinic/sysmodule.c.h
  function PyObject (line 23) | static PyObject *
  function PyObject (line 88) | static PyObject *
  function PyObject (line 124) | static PyObject *
  function PyObject (line 145) | static PyObject *
  function PyObject (line 185) | static PyObject *
  function PyObject (line 217) | static PyObject *
  function PyObject (line 235) | static PyObject *
  function PyObject (line 253) | static PyObject *
  function PyObject (line 275) | static PyObject *
  function PyObject (line 318) | static PyObject *
  function PyObject (line 350) | static PyObject *
  function PyObject (line 375) | static PyObject *
  function PyObject (line 409) | static PyObject *
  function PyObject (line 441) | static PyObject *
  function PyObject (line 474) | static PyObject *
  function PyObject (line 532) | static PyObject *
  function PyObject (line 562) | static PyObject *
  function PyObject (line 584) | static PyObject *
  function PyObject (line 614) | static PyObject *
  function PyObject (line 642) | static PyObject *
  function PyObject (line 672) | static PyObject *
  function PyObject (line 706) | static PyObject *
  function PyObject (line 727) | static PyObject *
  function PyObject (line 757) | static PyObject *
  function PyObject (line 775) | static PyObject *
  function PyObject (line 837) | static PyObject *
  function PyObject (line 866) | static PyObject *
  function PyObject (line 896) | static PyObject *
  function PyObject (line 924) | static PyObject *
  function PyObject (line 960) | static PyObject *
  function PyObject (line 997) | static PyObject *
  function PyObject (line 1017) | static PyObject *
  function PyObject (line 1039) | static PyObject *
  function PyObject (line 1076) | static PyObject *
  function PyObject (line 1094) | static PyObject *
  function PyObject (line 1112) | static PyObject *
  function PyObject (line 1132) | static PyObject *
  function PyObject (line 1154) | static PyObject *
  function PyObject (line 1176) | static PyObject *
  function PyObject (line 1198) | static PyObject *
  function PyObject (line 1220) | static PyObject *
  function PyObject (line 1240) | static PyObject *
  function PyObject (line 1279) | static PyObject *
  function PyObject (line 1297) | static PyObject *
  function PyObject (line 1321) | static PyObject *

FILE: Clinic/traceback.c.h
  function PyObject (line 21) | static PyObject *

FILE: CodeCS.c
  function PyCodec_Register (line 27) | int PyCodec_Register(PyObject *search_function)
  function PyCodec_Unregister (line 46) | int
  function PyObject (line 76) | static
  function PyObject (line 119) | PyObject *_PyCodec_Lookup(const char *encoding)
  function PyCodec_KnownEncoding (line 206) | int PyCodec_KnownEncoding(const char *encoding)
  function PyObject (line 221) | static
  function PyObject (line 246) | static
  function PyObject (line 261) | static
  function PyObject (line 279) | static
  function PyObject (line 296) | static
  function PyObject (line 320) | PyObject *_PyCodecInfo_GetIncrementalDecoder(PyObject *codec_info,
  function PyObject (line 327) | PyObject *_PyCodecInfo_GetIncrementalEncoder(PyObject *codec_info,
  function PyObject (line 341) | PyObject *PyCodec_Encoder(const char *encoding)
  function PyObject (line 346) | PyObject *PyCodec_Decoder(const char *encoding)
  function PyObject (line 351) | PyObject *PyCodec_IncrementalEncoder(const char *encoding,
  function PyObject (line 357) | PyObject *PyCodec_IncrementalDecoder(const char *encoding,
  function PyObject (line 363) | PyObject *PyCodec_StreamReader(const char *encoding,
  function PyObject (line 370) | PyObject *PyCodec_StreamWriter(const char *encoding,
  function PyObject (line 382) | static PyObject *
  function PyObject (line 427) | static PyObject *
  function PyObject (line 467) | PyObject *PyCodec_Encode(PyObject *object,
  function PyObject (line 480) | PyObject *PyCodec_Decode(PyObject *object,
  function PyObject (line 494) | PyObject * _PyCodec_LookupTextEncoding(const char *encoding,
  function PyObject (line 534) | static
  function PyObject (line 551) | static PyObject * _PyCodec_TextEncoder(const char *encoding)
  function PyObject (line 556) | static PyObject * _PyCodec_TextDecoder(const char *encoding)
  function PyObject (line 561) | PyObject *_PyCodec_EncodeText(PyObject *object,
  function PyObject (line 574) | PyObject *_PyCodec_DecodeText(PyObject *object,
  function PyCodec_RegisterError (line 593) | int PyCodec_RegisterError(const char *name, PyObject *error)
  function PyObject (line 609) | PyObject *PyCodec_LookupError(const char *name)
  function wrong_exception_type (line 629) | static void wrong_exception_type(PyObject *exc)
  function PyObject (line 636) | PyObject *PyCodec_StrictErrors(PyObject *exc)
  function PyObject (line 646) | PyObject *PyCodec_IgnoreErrors(PyObject *exc)
  function PyObject (line 670) | PyObject *PyCodec_ReplaceErrors(PyObject *exc)
  function PyObject (line 723) | PyObject *PyCodec_XMLCharRefReplaceErrors(PyObject *exc)
  function PyObject (line 821) | PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc)
  function PyObject (line 930) | PyObject *PyCodec_NameReplaceErrors(PyObject *exc)
  function get_standard_encoding (line 1031) | static int
  function PyObject (line 1092) | static PyObject *
  function PyObject (line 1256) | static PyObject *
  function PyObject (line 1334) | static PyObject *strict_errors(PyObject *self, PyObject *exc)
  function PyObject (line 1340) | static PyObject *ignore_errors(PyObject *self, PyObject *exc)
  function PyObject (line 1346) | static PyObject *replace_errors(PyObject *self, PyObject *exc)
  function PyObject (line 1352) | static PyObject *xmlcharrefreplace_errors(PyObject *self, PyObject *exc)
  function PyObject (line 1358) | static PyObject *backslashreplace_errors(PyObject *self, PyObject *exc)
  function PyObject (line 1363) | static PyObject *namereplace_errors(PyObject *self, PyObject *exc)
  function PyObject (line 1368) | static PyObject *surrogatepass_errors(PyObject *self, PyObject *exc)
  function PyObject (line 1373) | static PyObject *surrogateescape_errors(PyObject *self, PyObject *exc)
  function _PyCodecRegistry_Init (line 1378) | static int _PyCodecRegistry_Init(void)

FILE: Compile.c
  type _PyCompilerSrcLocation (line 45) | typedef _PyCompilerSrcLocation location;
  type _PyCfgInstruction (line 46) | typedef _PyCfgInstruction cfg_instr;
  type _PyCfgBasicblock (line 47) | typedef _PyCfgBasicblock basicblock;
  type _PyCfgBuilder (line 48) | typedef _PyCfgBuilder cfg_builder;
  function location_is_after (line 54) | static inline bool
  type _PyCfgJumpTargetLabel (line 63) | typedef _PyCfgJumpTargetLabel jump_target_label;
  type fblocktype (line 87) | enum fblocktype { WHILE_LOOP, FOR_LOOP, TRY_EXCEPT, FINALLY_TRY, FINALLY...
  type fblockinfo (line 91) | struct fblockinfo {
  function _PyCompile_InstrSize (line 111) | int
  type _PyCompile_Instruction (line 121) | typedef _PyCompile_Instruction instruction;
  type _PyCompile_InstructionSequence (line 122) | typedef _PyCompile_InstructionSequence instr_sequence;
  function _PyCompile_EnsureArrayLargeEnough (line 137) | int
  function instr_sequence_next_inst (line 182) | static int
  function jump_target_label (line 197) | static jump_target_label
  function instr_sequence_use_label (line 204) | static int
  function instr_sequence_addop (line 221) | static int
  function instr_sequence_insert_instruction (line 237) | static int
  function instr_sequence_fini (line 261) | static void
  function instr_sequence_to_cfg (line 270) | static int
  type compiler_unit (line 338) | struct compiler_unit {
  type compiler (line 367) | struct compiler {
  type pattern_context (line 386) | typedef struct {
  type compiler (line 413) | struct compiler
  type compiler (line 414) | struct compiler
  type compiler (line 415) | struct compiler
  type compiler (line 416) | struct compiler
  type compiler (line 418) | struct compiler
  type compiler (line 419) | struct compiler
  type compiler (line 420) | struct compiler
  type compiler (line 421) | struct compiler
  type compiler (line 422) | struct compiler
  type compiler (line 423) | struct compiler
  type compiler (line 424) | struct compiler
  type compiler (line 425) | struct compiler
  type compiler (line 430) | struct compiler
  type compiler (line 431) | struct compiler
  type compiler (line 432) | struct compiler
  type compiler (line 433) | struct compiler
  type compiler (line 437) | struct compiler
  type compiler (line 440) | struct compiler
  type compiler (line 441) | struct compiler
  type compiler (line 442) | struct compiler
  type compiler (line 445) | struct compiler
  type compiler (line 452) | struct compiler
  type compiler (line 458) | struct compiler
  type compiler (line 459) | struct compiler
  type compiler (line 460) | struct compiler
  type compiler (line 463) | struct compiler
  function compiler_setup (line 468) | static int
  type compiler (line 507) | struct compiler
  type compiler (line 512) | struct compiler
  type compiler (line 512) | struct compiler
  function PyCodeObject (line 523) | PyCodeObject *
  function compiler_free (line 539) | static void
  function PyObject (line 550) | static PyObject *
  function PyObject (line 584) | static PyObject *
  function compiler_unit_free (line 639) | static void
  function compiler_set_qualname (line 656) | static int
  function stack_effect (line 751) | static int
  function PyCompile_OpcodeStackEffectWithJump (line 828) | int
  function PyCompile_OpcodeStackEffect (line 834) | int
  function codegen_addop_noarg (line 840) | static int
  function Py_ssize_t (line 848) | static Py_ssize_t
  function PyObject (line 876) | static PyObject*
  function Py_ssize_t (line 983) | static Py_ssize_t
  function compiler_addop_load_const (line 997) | static int
  function compiler_addop_o (line 1007) | static int
  function compiler_addop_name (line 1018) | static int
  function codegen_addop_i (line 1061) | static int
  function codegen_addop_j (line 1077) | static int
  function compiler_enter_scope (line 1183) | static int
  function compiler_exit_scope (line 1296) | static void
  function find_ann (line 1325) | static bool
  function compiler_push_fblock (line 1406) | static int
  function compiler_pop_fblock (line 1423) | static void
  function compiler_call_exit_with_nones (line 1433) | static int
  function compiler_add_yield_from (line 1443) | static int
  function compiler_pop_except_and_reraise (line 1468) | static int
  function compiler_unwind_fblock (line 1489) | static int
  function compiler_unwind_fblock_stack (line 1590) | static int
  function compiler_body (line 1618) | static int
  function compiler_codegen (line 1657) | static int
  function PyCodeObject (line 1692) | static PyCodeObject *
  function get_ref_type (line 1709) | static int
  function compiler_lookup_arg (line 1732) | static int
  function compiler_make_closure (line 1742) | static int
  function compiler_decorators (line 1797) | static int
  function compiler_apply_decorators (line 1810) | static int
  function compiler_visit_kwonlydefaults (line 1824) | static int
  function compiler_visit_annexpr (line 1881) | static int
  function compiler_visit_argannotation (line 1889) | static int
  function compiler_visit_argannotations (line 1923) | static int
  function compiler_visit_annotations (line 1941) | static int
  function compiler_visit_defaults (line 1984) | static int
  function Py_ssize_t (line 1993) | static Py_ssize_t
  function forbidden_name (line 2014) | static bool
  function compiler_check_debug_one_arg (line 2029) | static int
  function compiler_check_debug_args_seq (line 2040) | static int
  function compiler_check_debug_args (line 2052) | static int
  function wrap_in_stopiteration_handler (line 2063) | static int
  function compiler_type_params (line 2082) | static int
  function compiler_function_body (line 2144) | static int
  function compiler_function (line 2211) | static int
  function compiler_set_type_params_in_class (line 2336) | static int
  function compiler_class_body (line 2345) | static int
  function compiler_class (line 2473) | static int
  function compiler_typealias_body (line 2573) | static int
  function compiler_typealias (line 2600) | static int
  function check_is_arg (line 2656) | static bool
  function check_compare (line 2674) | static int
  function compiler_addcompare (line 2711) | static int compiler_addcompare(struct compiler *c, location loc,
  function compiler_jump_if (line 2757) | static int
  function compiler_ifexp (line 2848) | static int
  function compiler_lambda (line 2868) | static int
  function compiler_if (line 2919) | static int
  function compiler_for (line 2947) | static int
  function compiler_async_for (line 2982) | static int
  function compiler_while (line 3032) | static int
  function compiler_return (line 3060) | static int
  function compiler_break (line 3101) | static int
  function compiler_continue (line 3117) | static int
  function location (line 3133) | static location
  function compiler_try_finally (line 3174) | static int
  function compiler_try_star_finally (line 3225) | static int
  function compiler_try_except (line 3305) | static int
  function compiler_try_star_except (line 3487) | static int
  function compiler_try (line 3654) | static int
  function compiler_try_star (line 3662) | static int
  function compiler_import_as (line 3673) | static int
  function compiler_import (line 3715) | static int
  function compiler_from_import (line 3761) | static int
  function compiler_assert (line 3820) | static int
  function compiler_stmt_expr (line 3850) | static int
  function compiler_visit_stmt (line 3871) | static int
  function unaryop (line 3969) | static int
  function addop_binary (line 3986) | static int
  function addop_yield (line 4041) | static int
  function compiler_nameop (line 4051) | static int
  function compiler_boolop (line 4186) | static int
  function starunpack_helper (line 4215) | static int
  function unpack_helper (line 4300) | static int
  function assignment_helper (line 4328) | static int
  function compiler_list (line 4340) | static int
  function compiler_tuple (line 4358) | static int
  function compiler_set (line 4376) | static int
  function are_all_items_const (line 4384) | static bool
  function compiler_subdict (line 4396) | static int
  function compiler_dict (line 4435) | static int
  function compiler_compare (line 4490) | static int
  function PyTypeObject (line 4530) | static PyTypeObject *
  function check_caller (line 4559) | static int
  function check_subscripter (line 4584) | static int
  function check_index (line 4613) | static int
  function is_import_originated (line 4649) | static int
  function can_optimize_super_call (line 4666) | static int
  function load_args_for_super (line 4719) | static int
  function location (line 4751) | static location
  function maybe_optimize_method_call (line 4778) | static int
  function validate_keywords (line 4845) | static int
  function compiler_call (line 4869) | static int
  function compiler_joined_str (line 4890) | static int
  function compiler_formatted_value (line 4916) | static int
  function compiler_subkwargs (line 4962) | static int
  function compiler_call_simple_kw_helper (line 5009) | static int
  function compiler_call_helper (line 5033) | static int
  function compiler_comprehension_generator (line 5144) | static int
  function compiler_sync_comprehension_generator (line 5164) | static int
  function compiler_async_comprehension_generator (line 5283) | static int
  type inlined_comprehension_state (line 5383) | typedef struct {
  function push_inlined_comprehension_state (line 5389) | static int
  function pop_inlined_comprehension_state (line 5497) | static int
  function compiler_comprehension_iter (line 5548) | static inline int
  function compiler_comprehension (line 5562) | static int
  function compiler_genexp (line 5695) | static int
  function compiler_listcomp (line 5705) | static int
  function compiler_setcomp (line 5715) | static int
  function compiler_dictcomp (line 5726) | static int
  function compiler_visit_keyword (line 5737) | static int
  function compiler_with_except_finish (line 5745) | static int
  function compiler_async_with (line 5791) | static int
  function compiler_with (line 5894) | static int
  function compiler_visit_expr1 (line 5959) | static int
  function compiler_visit_expr (line 6114) | static int
  function is_two_element_slice (line 6121) | static bool
  function compiler_augassign (line 6128) | static int
  function check_ann_expr (line 6203) | static int
  function check_annotation (line 6211) | static int
  function check_ann_subscr (line 6228) | static int
  function compiler_annassign (line 6258) | static int
  function compiler_error (line 6326) | static int
  function compiler_warn (line 6359) | static int
  function compiler_subscript (line 6387) | static int
  function compiler_slice (line 6425) | static int
  function ensure_fail_pop (line 6477) | static int
  function jump_to_fail_pop (line 6499) | static int
  function emit_and_reset_fail_pop (line 6512) | static int
  function compiler_error_duplicate_store (line 6535) | static int
  function pattern_helper_rotate (line 6543) | static int
  function pattern_helper_store_name (line 6552) | static int
  function pattern_unpack_helper (line 6577) | static int
  function pattern_helper_sequence_unpack (line 6606) | static int
  function pattern_helper_sequence_subscr (line 6628) | static int
  function compiler_pattern_subpattern (line 6666) | static int
  function compiler_pattern_as (line 6677) | static int
  function compiler_pattern_star (line 6703) | static int
  function validate_kwd_attrs (line 6712) | static int
  function compiler_pattern_class (line 6736) | static int
  function compiler_pattern_mapping (line 6800) | static int
  function compiler_pattern_or (line 6935) | static int
  function compiler_pattern_sequence (line 7087) | static int
  function compiler_pattern_value (line 7145) | static int
  function compiler_pattern_singleton (line 7160) | static int
  function compiler_pattern (line 7170) | static int
  function compiler_match_inner (line 7197) | static int
  function compiler_match (line 7274) | static int
  function PyObject (line 7287) | static PyObject *
  function compute_code_flags (line 7311) | static int
  function _PyCompile_ConstCacheMergeOne (line 7346) | int
  function insert_prefix_instructions (line 7408) | static int
  function fix_cell_offsets (line 7481) | static int
  function prepare_localsplus (line 7527) | static int
  function add_return_at_end (line 7562) | static int
  function PyCodeObject (line 7577) | static PyCodeObject *
  function PyCodeObject (line 7637) | static PyCodeObject *
  function cfg_to_instr_sequence (line 7656) | static int
  function instructions_to_instr_sequence (line 7700) | static int
  function instructions_to_cfg (line 7786) | static int
  function PyObject (line 7805) | static PyObject *
  function PyObject (line 7838) | static PyObject *
  function PyObject (line 7879) | PyObject *
  function PyObject (line 7964) | PyObject *
  function PyCodeObject (line 7991) | PyCodeObject *
  function PyObject (line 8058) | PyObject *

FILE: Condvar.h
  type timespec (line 16) | struct timespec
  function PyCOND_TIMEDWAIT (line 31) | Py_LOCAL_INLINE(int)
  function PyMUTEX_INIT (line 71) | Py_LOCAL_INLINE(int)
  function PyMUTEX_FINI (line 78) | Py_LOCAL_INLINE(int)
  function PyMUTEX_LOCK (line 85) | Py_LOCAL_INLINE(int)
  function PyMUTEX_UNLOCK (line 92) | Py_LOCAL_INLINE(int)
  function PyCOND_INIT (line 100) | Py_LOCAL_INLINE(int)
  function PyCOND_FINI (line 114) | Py_LOCAL_INLINE(int)
  function _PyCOND_WAIT_MS (line 123) | Py_LOCAL_INLINE(int)
  function PyCOND_WAIT (line 154) | Py_LOCAL_INLINE(int)
  function PyCOND_TIMEDWAIT (line 161) | Py_LOCAL_INLINE(int)
  function PyCOND_SIGNAL (line 167) | Py_LOCAL_INLINE(int)
  function PyCOND_BROADCAST (line 185) | Py_LOCAL_INLINE(int)
  function PyMUTEX_INIT (line 198) | Py_LOCAL_INLINE(int)
  function PyMUTEX_FINI (line 205) | Py_LOCAL_INLINE(int)
  function PyMUTEX_LOCK (line 211) | Py_LOCAL_INLINE(int)
  function PyMUTEX_UNLOCK (line 218) | Py_LOCAL_INLINE(int)
  function PyCOND_INIT (line 226) | Py_LOCAL_INLINE(int)
  function PyCOND_FINI (line 232) | Py_LOCAL_INLINE(int)
  function PyCOND_WAIT (line 238) | Py_LOCAL_INLINE(int)
  function PyCOND_TIMEDWAIT (line 247) | Py_LOCAL_INLINE(int)
  function PyCOND_SIGNAL (line 253) | Py_LOCAL_INLINE(int)
  function PyCOND_BROADCAST (line 260) | Py_LOCAL_INLINE(int)

FILE: Context.c
  type _Py_context_state (line 68) | struct _Py_context_state
  function PyObject (line 77) | PyObject *
  function PyObject (line 84) | PyObject *
  function PyObject (line 91) | PyObject *
  function PyObject (line 100) | PyObject *
  function _PyContext_Enter (line 112) | static int
  function PyContext_Enter (line 134) | int
  function _PyContext_Exit (line 143) | static int
  function PyContext_Exit (line 172) | int
  function PyObject (line 181) | PyObject *
  function PyContextVar_Get (line 194) | int
  function PyObject (line 257) | PyObject *
  function PyContextVar_Reset (line 293) | int
  function PyContext (line 339) | static inline PyContext *
  function PyContext (line 375) | static PyContext *
  function PyContext (line 394) | static PyContext *
  function PyContext (line 409) | static inline PyContext *
  function context_check_key_type (line 425) | static int
  function PyObject (line 437) | static PyObject *
  function context_tp_clear (line 448) | static int
  function context_tp_traverse (line 456) | static int
  function context_tp_dealloc (line 464) | static void
  function PyObject (line 493) | static PyObject *
  function PyObject (line 499) | static PyObject *
  function Py_ssize_t (line 526) | static Py_ssize_t
  function PyObject (line 532) | static PyObject *
  function context_tp_contains (line 550) | static int
  function PyObject (line 573) | static PyObject *
  function PyObject (line 602) | static PyObject *
  function PyObject (line 616) | static PyObject *
  function PyObject (line 630) | static PyObject *
  function PyObject (line 644) | static PyObject *
  function PyObject (line 652) | static PyObject *
  function contextvar_set (line 730) | static int
  function contextvar_del (line 755) | static int
  function Py_hash_t (line 781) | static Py_hash_t
  function PyContextVar (line 809) | static PyContextVar *
  function PyObject (line 852) | static PyObject *
  function contextvar_tp_clear (line 868) | static int
  function contextvar_tp_traverse (line 879) | static int
  function contextvar_tp_dealloc (line 887) | static void
  function Py_hash_t (line 895) | static Py_hash_t
  function PyObject (line 901) | static PyObject *
  function PyObject (line 972) | static PyObject *
  function PyObject (line 1008) | static PyObject *
  function PyObject (line 1026) | static PyObject *
  function PyObject (line 1087) | static PyObject *
  function token_tp_clear (line 1095) | static int
  function token_tp_traverse (line 1104) | static int
  function token_tp_dealloc (line 1113) | static void
  function PyObject (line 1121) | static PyObject *
  function PyObject (line 1169) | static PyObject *
  function PyObject (line 1175) | static PyObject *
  function PyContextToken (line 1214) | static PyContextToken *
  function PyObject (line 1238) | static PyObject *
  function context_token_missing_tp_dealloc (line 1244) | static void
  function PyObject (line 1267) | static PyObject *
  function _PyContext_ClearFreeList (line 1277) | void
  function _PyContext_Fini (line 1292) | void
  function PyStatus (line 1303) | PyStatus

FILE: Dtoa.c
  type Long (line 142) | typedef int32_t Long;
  type ULLong (line 143) | typedef uint64_t ULLong;
  type U (line 160) | typedef union { double d; ULong L[2]; } U;
  type BCinfo (line 264) | typedef struct BCinfo BCinfo;
  type BCinfo (line 265) | struct
  type Bigint (line 295) | typedef struct Bigint Bigint;
  function Bigint (line 324) | static Bigint *
  function Bfree (line 358) | static void
  function Bigint (line 385) | static Bigint *
  function Bfree (line 408) | static void
  function Bigint (line 425) | static Bigint *
  function Bigint (line 466) | static Bigint *
  function hi0bits (line 501) | static int
  function lo0bits (line 533) | static int
  function Bigint (line 578) | static Bigint *
  function Bigint (line 594) | static Bigint *
  function Bigint (line 658) | static Bigint *
  function Bigint (line 715) | static Bigint *
  function Bigint (line 766) | static Bigint *
  function cmp (line 813) | static int
  function Bigint (line 846) | static Bigint *
  function ulp (line 903) | static double
  function b2d (line 917) | static double
  function Bigint (line 973) | static Bigint *
  function Bigint (line 1031) | static Bigint *
  function ratio (line 1079) | static double
  function dshift (line 1120) | static int
  function quorem (line 1133) | static int
  function sulp (line 1205) | static double
  function bigcomp (line 1268) | static int
  function _Py_dg_strtod (line 1379) | double
  function _Py_dg_freedtoa (line 2142) | void

FILE: Dup2.c
  function dup2 (line 7) | int

FILE: Dynamic_Annotations.c
  function AnnotateRWLockCreate (line 21) | void AnnotateRWLockCreate(const char *file, int line,
  function AnnotateRWLockDestroy (line 23) | void AnnotateRWLockDestroy(const char *file, int line,
  function AnnotateRWLockAcquired (line 25) | void AnnotateRWLockAcquired(const char *file, int line,
  function AnnotateRWLockReleased (line 27) | void AnnotateRWLockReleased(const char *file, int line,
  function AnnotateBarrierInit (line 29) | void AnnotateBarrierInit(const char *file, int line,
  function AnnotateBarrierWaitBefore (line 32) | void AnnotateBarrierWaitBefore(const char *file, int line,
  function AnnotateBarrierWaitAfter (line 34) | void AnnotateBarrierWaitAfter(const char *file, int line,
  function AnnotateBarrierDestroy (line 36) | void AnnotateBarrierDestroy(const char *file, int line,
  function AnnotateCondVarWait (line 39) | void AnnotateCondVarWait(const char *file, int line,
  function AnnotateCondVarSignal (line 42) | void AnnotateCondVarSignal(const char *file, int line,
  function AnnotateCondVarSignalAll (line 44) | void AnnotateCondVarSignalAll(const char *file, int line,
  function AnnotatePublishMemoryRange (line 46) | void AnnotatePublishMemoryRange(const char *file, int line,
  function AnnotateUnpublishMemoryRange (line 49) | void AnnotateUnpublishMemoryRange(const char *file, int line,
  function AnnotatePCQCreate (line 52) | void AnnotatePCQCreate(const char *file, int line,
  function AnnotatePCQDestroy (line 54) | void AnnotatePCQDestroy(const char *file, int line,
  function AnnotatePCQPut (line 56) | void AnnotatePCQPut(const char *file, int line,
  function AnnotatePCQGet (line 58) | void AnnotatePCQGet(const char *file, int line,
  function AnnotateNewMemory (line 60) | void AnnotateNewMemory(const char *file, int line,
  function AnnotateExpectRace (line 63) | void AnnotateExpectRace(const char *file, int line,
  function AnnotateBenignRace (line 66) | void AnnotateBenignRace(const char *file, int line,
  function AnnotateBenignRaceSized (line 69) | void AnnotateBenignRaceSized(const char *file, int line,
  function AnnotateMutexIsUsedAsCondVar (line 73) | void AnnotateMutexIsUsedAsCondVar(const char *file, int line,
  function AnnotateTraceMemory (line 75) | void AnnotateTraceMemory(const char *file, int line,
  function AnnotateThreadName (line 77) | void AnnotateThreadName(const char *file, int line,
  function AnnotateIgnoreReadsBegin (line 79) | void AnnotateIgnoreReadsBegin(const char *file, int line){}
  function AnnotateIgnoreReadsEnd (line 80) | void AnnotateIgnoreReadsEnd(const char *file, int line){}
  function AnnotateIgnoreWritesBegin (line 81) | void AnnotateIgnoreWritesBegin(const char *file, int line){}
  function AnnotateIgnoreWritesEnd (line 82) | void AnnotateIgnoreWritesEnd(const char *file, int line){}
  function AnnotateIgnoreSyncBegin (line 83) | void AnnotateIgnoreSyncBegin(const char *file, int line){}
  function AnnotateIgnoreSyncEnd (line 84) | void AnnotateIgnoreSyncEnd(const char *file, int line){}
  function AnnotateEnableRaceDetection (line 85) | void AnnotateEnableRaceDetection(const char *file, int line, int enable){}
  function AnnotateNoOp (line 86) | void AnnotateNoOp(const char *file, int line,
  function AnnotateFlushState (line 88) | void AnnotateFlushState(const char *file, int line){}
  function GetRunningOnValgrind (line 90) | static int GetRunningOnValgrind(void) {
  function RunningOnValgrind (line 117) | int RunningOnValgrind(void) {

FILE: Dynload_Hpux.c
  function dl_funcptr (line 18) | dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix,

FILE: Dynload_Shlib.c
  function dl_funcptr (line 52) | dl_funcptr

FILE: Dynload_Win.c
  function _Py_CheckPython3 (line 174) | static int
  function dl_funcptr (line 222) | dl_funcptr _PyImport_FindSharedFuncptrWindows(const char *prefix,

FILE: Emscripten_Signal.c
  function catch (line 19) | catch(e) {
  function _Py_CheckEmscriptenSignals (line 29) | void
  function _Py_CheckEmscriptenSignalsPeriodically (line 45) | void

FILE: Errors.c
  function _PyErr_SetRaisedException (line 30) | void
  function PyObject (line 38) | static PyObject*
  function _PyErr_Restore (line 64) | void
  function PyErr_Restore (line 110) | void
  function PyErr_SetRaisedException (line 117) | void
  function _PyErr_StackItem (line 124) | _PyErr_StackItem *
  function PyObject (line 138) | static PyObject *
  function _PyErr_SetObject (line 160) | void
  function PyErr_SetObject (line 252) | void
  function _PyErr_SetKeyError (line 262) | void
  function _PyErr_SetNone (line 275) | void
  function PyErr_SetNone (line 282) | void
  function _PyErr_SetString (line 290) | void
  function PyErr_SetString (line 299) | void
  function PyErr_Occurred (line 308) | PyErr_Occurred(void)
  function PyErr_GivenExceptionMatches (line 318) | int
  function _PyErr_ExceptionMatches (line 350) | int
  function PyErr_ExceptionMatches (line 357) | int
  function _PyErr_NormalizeException (line 375) | void
  function PyErr_NormalizeException (line 478) | void
  function PyObject (line 486) | PyObject *
  function PyObject (line 493) | PyObject *
  function _PyErr_Fetch (line 500) | void
  function PyErr_Fetch (line 517) | void
  function _PyErr_Clear (line 525) | void
  function PyErr_Clear (line 532) | void
  function PyObject (line 539) | static PyObject*
  function PyObject (line 553) | static PyObject*
  function _PyErr_GetExcInfo (line 567) | void
  function PyObject (line 578) | PyObject*
  function PyObject (line 589) | PyObject*
  function _PyErr_SetHandledException (line 596) | void
  function PyErr_SetHandledException (line 602) | void
  function PyErr_GetExcInfo (line 609) | void
  function PyErr_SetExcInfo (line 616) | void
  function PyObject (line 627) | PyObject*
  function _PyErr_ChainExceptions (line 652) | void
  function _PyErr_ChainExceptions1 (line 689) | void
  function _PyErr_ChainStackItem (line 712) | void
  function PyObject (line 730) | static PyObject *
  function PyObject (line 746) | PyObject *
  function PyObject (line 757) | PyObject *
  function PyErr_BadArgument (line 770) | int
  function PyObject (line 779) | PyObject *
  function PyObject (line 786) | PyObject *
  function PyObject (line 792) | PyObject *
  function PyObject (line 891) | PyObject *
  function PyObject (line 900) | PyObject *
  function PyObject (line 908) | PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(
  function PyObject (line 917) | PyObject *PyErr_SetExcFromWindowsErrWithFilenameObjects(
  function PyObject (line 986) | PyObject *PyErr_SetExcFromWindowsErrWithFilename(
  function PyObject (line 1000) | PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)
  function PyObject (line 1005) | PyObject *PyErr_SetFromWindowsErr(int ierr)
  function PyObject (line 1011) | PyObject *PyErr_SetFromWindowsErrWithFilename(
  function PyObject (line 1025) | static PyObject *
  function PyObject (line 1087) | PyObject *
  function PyObject (line 1094) | PyObject *
  function PyObject (line 1100) | PyObject *
  function _PyErr_BadInternalCall (line 1106) | void
  function PyErr_BadInternalCall (line 1118) | void
  function PyObject (line 1129) | static PyObject *
  function PyObject (line 1147) | PyObject *
  function PyObject (line 1155) | PyObject *
  function PyObject (line 1167) | PyObject *
  function _PyErr_FormatNote (line 1180) | void
  function PyObject (line 1206) | PyObject *
  function PyObject (line 1261) | PyObject *
  function PyStatus (line 1318) | PyStatus
  function _PyErr_FiniTypes (line 1330) | void
  function PyObject (line 1337) | static PyObject *
  function write_unraisable_exc_file (line 1378) | static int
  function write_unraisable_exc (line 1498) | static int
  function PyObject (line 1519) | PyObject*
  function _PyErr_WriteUnraisableMsg (line 1556) | void
  function PyErr_WriteUnraisable (line 1659) | void
  function PyErr_SyntaxLocation (line 1666) | void
  function PyErr_SyntaxLocationObjectEx (line 1677) | static void
  function PyErr_SyntaxLocationObject (line 1785) | void
  function PyErr_RangedSyntaxLocationObject (line 1790) | void
  function PyErr_SyntaxLocationEx (line 1796) | void
  function PyObject (line 1820) | static PyObject *
  function PyObject (line 1861) | PyObject *
  function PyObject (line 1878) | PyObject *
  function PyObject (line 1894) | PyObject *

FILE: Fileutils.c
  function get_surrogateescape (line 57) | static int
  function PyObject (line 74) | PyObject *
  function is_valid_wide_char (line 115) | static int
  function _Py_mbstowcs (line 139) | static size_t
  function _Py_mbrtowc (line 156) | static size_t
  function check_force_ascii (line 206) | static int
  function _Py_GetForceASCII (line 307) | int
  function _Py_ResetForceASCII (line 317) | void
  function encode_ascii (line 324) | static int
  function _Py_GetForceASCII (line 384) | int
  function _Py_ResetForceASCII (line 390) | void
  function decode_ascii (line 399) | static int
  function decode_current_locale (line 451) | static int
  function _Py_DecodeLocaleEx (line 598) | int
  function wchar_t (line 660) | wchar_t*
  function encode_current_locale (line 678) | static int
  function encode_locale_ex (line 789) | static int
  function _Py_EncodeLocaleEx (line 878) | int
  function wchar_t (line 899) | wchar_t*
  function PyObject (line 935) | PyObject *
  function _Py_LocaleUsesNonUnicodeWchar (line 952) | int
  function wchar_t (line 965) | static wchar_t *
  function wchar_t (line 1015) | wchar_t *
  function _Py_EncodeNonUnicodeWchar_InPlace (line 1033) | int
  function FILE_TIME_to_time_t_nsec (line 1049) | static void
  function LARGE_INTEGER_to_time_t_nsec (line 1061) | static void
  function _Py_time_t_to_FILE_TIME (line 1068) | void
  function attributes_to_mode (line 1082) | static int
  type id_128_to_ino (line 1098) | typedef union {
  function _Py_attribute_data_to_stat (line 1107) | void
  function _Py_stat_basic_info_to_stat (line 1154) | void
  function _Py_fstat_noraise (line 1232) | int
  function _Py_fstat (line 1301) | int
  function _Py_wstat (line 1324) | int
  function _Py_stat (line 1354) | int
  function get_inheritable (line 1397) | static int
  function _Py_get_inheritable (line 1434) | int
  function set_inheritable (line 1442) | static int
  function make_non_inheritable (line 1572) | static int
  function _Py_set_inheritable (line 1594) | int
  function _Py_set_inheritable_async_safe (line 1603) | int
  function _Py_open_impl (line 1609) | static int
  function _Py_open (line 1680) | int
  function _Py_open_noraise (line 1694) | int
  function FILE (line 1706) | FILE *
  function FILE (line 1754) | FILE*
  function Py_ssize_t (line 1846) | Py_ssize_t
  function Py_ssize_t (line 1905) | static Py_ssize_t
  function Py_ssize_t (line 2016) | Py_ssize_t
  function Py_ssize_t (line 2036) | Py_ssize_t
  function _Py_wreadlink (line 2049) | int
  function wchar_t (line 2098) | wchar_t*
  function _Py_isabs (line 2135) | int
  function _Py_abspath (line 2164) | int
  function HRESULT (line 2226) | HRESULT
  function HRESULT (line 2254) | static HRESULT
  function join_relfile (line 2289) | static int
  function wchar_t (line 2328) | wchar_t *
  function _Py_add_relfile (line 2356) | int
  function _Py_find_basename (line 2365) | size_t
  function wchar_t (line 2381) | wchar_t *
  function wchar_t (line 2511) | wchar_t*
  function _Py_dup (line 2543) | int
  function _Py_get_blocking (line 2613) | int
  function _Py_set_blocking (line 2634) | int
  function _Py_get_blocking (line 2670) | int
  function _Py_set_blocking (line 2695) | int
  function _Py_open_osfhandle_noraise (line 2748) | int
  function _Py_open_osfhandle (line 2758) | int
  function _Py_GetLocaleconvNumeric (line 2769) | int
  function _fdwalk_close_func (line 2867) | static int
  function _Py_closerange (line 2885) | void

FILE: Flowgraph.c
  type _PyCompilerSrcLocation (line 27) | typedef _PyCompilerSrcLocation location;
  type _PyCfgJumpTargetLabel (line 28) | typedef _PyCfgJumpTargetLabel jump_target_label;
  type _PyCfgBasicblock (line 29) | typedef _PyCfgBasicblock basicblock;
  type _PyCfgBuilder (line 30) | typedef _PyCfgBuilder cfg_builder;
  type _PyCfgInstruction (line 31) | typedef _PyCfgInstruction cfg_instr;
  function is_block_push (line 39) | static inline int
  function is_jump (line 45) | static inline int
  function basicblock_next_instr (line 75) | static int
  function basicblock (line 93) | static basicblock *
  function basicblock_addop (line 108) | static int
  function basicblock_append_instructions (line 129) | static inline int
  function basicblock (line 142) | static basicblock *
  function _PyBasicblock_InsertInstruction (line 159) | int
  function instr_size (line 169) | static int
  function blocksize (line 175) | static int
  function dump_instr (line 187) | static void
  function basicblock_returns (line 205) | static inline int
  function dump_basicblock (line 211) | static void
  function _PyCfgBuilder_DumpGraph (line 227) | void
  function basicblock (line 240) | static basicblock *
  function cfg_instr (line 249) | cfg_instr *
  function basicblock_exits_scope (line 259) | static inline int
  function cfg_builder_current_block_is_terminated (line 265) | static bool
  function cfg_builder_maybe_start_new_block (line 285) | static int
  function cfg_builder_check (line 301) | static bool
  function _PyCfgBuilder_Init (line 321) | int
  function _PyCfgBuilder_Fini (line 334) | void
  function _PyCfgBuilder_UseLabel (line 349) | int
  function _PyCfgBuilder_Addop (line 356) | int
  function no_redundant_nops (line 369) | static bool
  function no_empty_basic_blocks (line 379) | static bool
  function no_redundant_jumps (line 389) | static bool
  function normalize_jumps_in_block (line 409) | static int
  function normalize_jumps (line 469) | static int
  function resolve_jump_offsets (line 483) | static void
  function _PyCfg_ResolveJumps (line 542) | int
  function check_cfg (line 551) | static int
  function translate_jump_labels_to_targets (line 570) | static int
  function _PyCfg_JumpLabelsToTargets (line 608) | int
  function mark_except_handlers (line 614) | static int
  type _PyCfgExceptStack (line 633) | typedef _PyCfgExceptStack ExceptStack;
  function basicblock (line 635) | static basicblock *
  function basicblock (line 647) | static basicblock *
  function basicblock (line 653) | static basicblock *
  function ExceptStack (line 658) | static ExceptStack *
  function ExceptStack (line 670) | static ExceptStack *
  function basicblock (line 681) | static basicblock**
  function stackdepth_push (line 695) | Py_LOCAL_INLINE(void)
  function _PyCfg_Stackdepth (line 709) | int
  function label_exception_targets (line 776) | static int
  function mark_reachable (line 873) | static int
  function eliminate_empty_basic_blocks (line 909) | static void
  function remove_redundant_nops (line 938) | static int
  function remove_redundant_nops_and_pairs (line 991) | static int
  function remove_redundant_jumps (line 1035) | static int
  function inline_small_exit_blocks (line 1068) | static int
  function jump_thread (line 1089) | static bool
  function PyObject (line 1106) | static PyObject*
  function fold_tuple_on_constants (line 1129) | static int
  function swaptimize (line 1194) | static int
  function next_swappable_instruction (line 1305) | static int
  function apply_static_swaps (line 1329) | static void
  function optimize_basic_block (line 1381) | static int
  function optimize_cfg (line 1571) | static int
  function make_super_instruction (line 1606) | static void
  function insert_superinstructions (line 1622) | static void
  function maybe_push (line 1657) | static inline void
  function scan_block_for_locals (line 1675) | static void
  function fast_scan_many_locals (line 1722) | static int
  function remove_unused_consts (line 1769) | static int
  function add_checks_for_loads_of_uninitialized_variables (line 1866) | static int
  function mark_warm (line 1916) | static int
  function mark_cold (line 1947) | static int
  function push_cold_blocks_to_end (line 1997) | static int
  function _PyCfg_ConvertPseudoOps (line 2071) | void
  function is_exit_without_lineno (line 2092) | static inline bool
  function duplicate_exits_without_lineno (line 2114) | static int
  function propagate_line_numbers (line 2163) | static void
  function guarantee_lineno_for_exits (line 2201) | static void
  function resolve_line_numbers (line 2225) | static int
  function _PyCfg_OptimizeCodeUnit (line 2234) | int

FILE: Formatter_Unicode.c
  function unknown_presentation_type (line 13) | static void
  function invalid_thousands_separator_type (line 32) | static void
  function invalid_comma_and_underscore (line 46) | static void
  function get_integer (line 59) | static int
  function is_alignment_token (line 97) | Py_LOCAL_INLINE(int)
  function is_sign_element (line 109) | Py_LOCAL_INLINE(int)
  type LocaleType (line 121) | enum LocaleType {
  type InternalFormatSpec (line 129) | typedef struct {
  function parse_internal_render_format_spec (line 148) | static int
  function calc_padding (line 336) | static void
  function fill_padding (line 370) | static int
  type LocaleInfo (line 402) | typedef struct {
  type NumberFieldWidths (line 413) | typedef struct {
  function parse_number (line 446) | static void
  function Py_ssize_t (line 473) | static Py_ssize_t
  function fill_number (line 602) | static int
  function get_locale_info (line 703) | static int
  function free_locale_info (line 752) | static void
  function format_string_internal (line 764) | static int
  function format_long_internal (line 863) | static int
  function format_float_internal (line 1041) | static int
  function format_complex_internal (line 1190) | static int
  function format_obj (line 1436) | static int
  function _PyUnicode_FormatAdvancedWriter (line 1450) | int
  function _PyLong_FormatAdvancedWriter (line 1486) | int
  function _PyFloat_FormatAdvancedWriter (line 1548) | int
  function _PyComplex_FormatAdvancedWriter (line 1587) | int

FILE: Frame.c
  function _PyFrame_Traverse (line 11) | int
  function PyFrameObject (line 28) | PyFrameObject *
  function _PyFrame_Copy (line 65) | void
  function take_ownership (line 77) | static void
  function _PyFrame_ClearExceptCode (line 118) | void
  function PyObject (line 149) | PyObject *
  function PyUnstable_InterpreterFrame_GetLasti (line 157) | int
  function PyUnstable_InterpreterFrame_GetLine (line 163) | int

FILE: Frozen.c
  type _frozen (line 103) | struct _frozen
  type _frozen (line 109) | struct _frozen
  type _frozen (line 132) | struct _frozen
  type _frozen (line 146) | struct _frozen
  type _frozen (line 147) | struct _frozen
  type _frozen (line 148) | struct _frozen
  type _module_alias (line 150) | struct _module_alias
  type _module_alias (line 162) | struct _module_alias
  type _frozen (line 168) | struct _frozen

FILE: FrozenMain.c
  function Py_FrozenMain (line 15) | int

FILE: Future.c
  function future_check_features (line 6) | static int
  function future_parse (line 54) | static int
  function _PyFuture_FromAST (line 99) | int

FILE: Game I/c_key_event.h
  type C_KeyState (line 12) | typedef enum C_KeyState
  type C_Key (line 21) | typedef enum C_Key
  type C_KeyEvent (line 31) | typedef struct C_KeyEvent

FILE: Game I/c_list.c
  type Node (line 17) | typedef struct Node
  type C_List (line 27) | typedef struct C_List
  type C_ListIter (line 35) | typedef struct C_ListIter
  function C_Result (line 40) | C_Result c_list_create(C_List **list)
  function c_list_destroy (line 73) | void c_list_destroy(C_List *list)
  function C_Result (line 101) | C_Result c_list_push_back(C_List *list, void *value)
  function C_Result (line 106) | C_Result c_list_push_back_dtor(C_List *list, void *value, void (*dtor)(v...
  function c_list_remove (line 136) | void c_list_remove(C_List *list, const C_ListIter *iter)
  function C_Result (line 166) | C_Result c_list_iterator_create(const C_List *list, C_ListIter **iter)
  function c_list_iterator_destroy (line 190) | void c_list_iterator_destroy(C_ListIter *iter)
  function c_list_iterator_advance (line 195) | void c_list_iterator_advance(C_ListIter **iter)
  function c_list_iterator_reset (line 202) | void c_list_iterator_reset(const C_List *list, C_ListIter **iter)
  function c_list_iterator_at_end (line 209) | bool c_list_iterator_at_end(C_ListIter *iter)

FILE: Game I/c_list.h
  type C_List (line 20) | typedef struct C_List C_List;
  type C_ListIter (line 25) | typedef struct C_ListIter C_ListIter;

FILE: Game I/c_rectangle.c
  function C_Rectangle (line 14) | C_Rectangle c_rectangle_create(const C_Vector2 *position, float width, f...
  function C_Rectangle (line 19) | C_Rectangle c_rectangle_create_xy(float x, float y, float width, float h...
  function c_rectangle_translate (line 25) | void c_rectangle_translate(C_Rectangle *rectangle, const C_Vector2 *tran...
  function c_rectangle_translate_xy (line 30) | void c_rectangle_translate_xy(C_Rectangle *rectangle, float x, float y)
  function c_rectangle_set_position (line 35) | void c_rectangle_set_position(C_Rectangle *rectangle, const C_Vector2 *p...
  function c_rectangle_set_position_xy (line 40) | void c_rectangle_set_position_xy(C_Rectangle *rectangle, float x, float y)
  function c_rectangle_print (line 46) | void c_rectangle_print(const C_Rectangle *rectangle)

FILE: Game I/c_rectangle.h
  type C_Rectangle (line 19) | typedef struct C_Rectangle

FILE: Game I/c_result.h
  type C_Result (line 12) | typedef enum C_Result

FILE: Game I/c_vector2.c
  function C_Vector2 (line 12) | C_Vector2 c_vector2_create()
  function C_Vector2 (line 17) | C_Vector2 c_vector2_create_xy(float x, float y)
  function c_vector2_add (line 23) | void c_vector2_add(C_Vector2 *vec1, const C_Vector2 *vec2)
  function c_vector2_add_xy (line 32) | void c_vector2_add_xy(C_Vector2 *vec, float x, float y)
  function c_vector2_print (line 40) | void c_vector2_print(const C_Vector2 *vec)

FILE: Game I/c_vector2.h
  type C_Vector2 (line 16) | typedef struct C_Vector2

FILE: Game I/c_window.c
  type C_Window (line 19) | typedef struct C_Window
  function C_Result (line 25) | static C_Result map_sdl_key(C_Key *key, SDL_Keycode sdl_code)
  function C_Result (line 36) | C_Result c_window_create(C_Window **window)
  function c_window_destroy (line 82) | void c_window_destroy(C_Window *window)
  function C_Result (line 99) | C_Result c_window_get_event(const C_Window *window, C_KeyEvent *event)
  function C_Result (line 134) | C_Result c_window_pre_render(const C_Window *window)
  function c_window_post_render (line 156) | void c_window_post_render(const C_Window *window)
  function C_Result (line 161) | C_Result c_window_draw_rectangle(const C_Window *window, const C_Rectang...

FILE: Game I/c_window.h
  type C_Window (line 22) | typedef struct C_Window C_Window;

FILE: Game I/main.c
  type Entity (line 21) | typedef struct Entity
  function create_brick_row (line 61) | static void create_brick_row(C_List *entities, float y, uint8_t r, uint8...
  function update_ball (line 91) | static void update_ball(Entity *ball, C_Vector2 *ball_velocity)
  function check_collision (line 119) | bool static check_collision(const Entity *entity1, const Entity *entity2)
  function handle_collisions (line 143) | static void handle_collisions(C_List *entities, Entity *ball, C_Vector2 ...
  function main (line 195) | int main()

FILE: Game II/colour.cpp
  type cpp (line 12) | namespace cpp

FILE: Game II/colour.h
  function namespace (line 12) | namespace cpp

FILE: Game II/entity.cpp
  type cpp (line 15) | namespace cpp
    function Rectangle (line 24) | Rectangle Entity::rectangle() const
    function Colour (line 29) | Colour Entity::colour() const

FILE: Game II/entity.h
  function namespace (line 13) | namespace cpp

FILE: Game II/key_event.h
  type class (line 15) | enum class
  function Key (line 24) | enum class Key

FILE: Game II/main.cpp
  function create_brick_row (line 32) | void create_brick_row(std::vector<cpp::Entity> &entities, float y, const...
  function check_collisions (line 58) | void check_collisions(
  function update_ball (line 115) | void update_ball(cpp::Entity &ball, cpp::Vector2 &velocity)
  function update_paddle (line 141) | void update_paddle(cpp::Entity &paddle, const cpp::Vector2 &velocity)
  function main (line 148) | int main()

FILE: Game II/rectangle.cpp
  type cpp (line 13) | namespace cpp

FILE: Game II/rectangle.h
  function namespace (line 13) | namespace cpp

FILE: Game II/vector2.cpp
  type cpp (line 11) | namespace cpp
    function Vector2 (line 35) | Vector2 operator+(const Vector2 &v1, const Vector2 &v2)
    function Vector2 (line 42) | Vector2 &operator+=(Vector2 &v1, const Vector2 &v2)

FILE: Game II/vector2.h
  function namespace (line 11) | namespace cpp

FILE: Game II/window.cpp
  function map_sdl_key (line 31) | std::optional<cpp::Key> map_sdl_key(SDL_Keycode sdl_code)
  type cpp (line 46) | namespace cpp

FILE: Game II/window.h
  type SDL_Window (line 16) | struct SDL_Window
  type SDL_Renderer (line 17) | struct SDL_Renderer
  function namespace (line 22) | namespace cpp

FILE: GeTargs.c
  type freelistentry_t (line 34) | typedef struct {
  type freelist_t (line 39) | typedef struct {
  type _PyArg_Parser (line 64) | struct _PyArg_Parser
  type _PyArg_Parser (line 67) | struct _PyArg_Parser
  function PyArg_Parse (line 71) | int
  function _PyArg_Parse_SizeT (line 83) | PyAPI_FUNC(int)
  function PyArg_ParseTuple (line 96) | int
  function _PyArg_ParseTuple_SizeT (line 108) | int
  function _PyArg_ParseStack (line 121) | int
  function PyArg_VaParse (line 133) | int
  function _PyArg_VaParse_SizeT (line 146) | int
  function cleanup_ptr (line 162) | static int
  function cleanup_buffer (line 171) | static int
  function addcleanup (line 181) | static int
  function cleanreturn (line 195) | static int
  function vgetargs1_impl (line 215) | static int
  function vgetargs1 (line 372) | static int
  function seterror (line 399) | static void
  function _PyArg_BadArgument (line 577) | void
  function Py_ssize_t (line 1225) | static Py_ssize_t
  function getbuffer (line 1247) | static int
  function PyArg_ParseTupleAndKeywords (line 1266) | int
  function _PyArg_ParseTupleAndKeywords_SizeT (line 1290) | int
  function PyArg_VaParseTupleAndKeywords (line 1316) | int
  function _PyArg_VaParseTupleAndKeywords_SizeT (line 1341) | int
  function _PyArg_ParseTupleAndKeywordsFast (line 1367) | PyAPI_FUNC(int)
  function _PyArg_ParseTupleAndKeywordsFast_SizeT (line 1380) | int
  function _PyArg_ParseStackAndKeywords (line 1393) | int
  function _PyArg_ParseStackAndKeywords_SizeT (line 1406) | int
  function _PyArg_VaParseTupleAndKeywordsFast (line 1420) | PyAPI_FUNC(int)
  function error_unexpected_keyword_arg (line 1434) | static void
  function PyArg_ValidateKeywordArguments (line 1478) | int
  function vgetargskeywords (line 1495) | static int
  function scan_keywords (line 1779) | static int
  function parse_format (line 1800) | static int
  function PyObject (line 1881) | static PyObject *
  function _parser_init (line 1902) | static int
  function parser_init (line 1959) | static int
  function parser_clear (line 1981) | static void
  function PyObject (line 1989) | static PyObject*
  function vgetargskeywordsfast_impl (line 2015) | static int
  function vgetargskeywordsfast (line 2228) | static int
  function PyObject (line 2252) | PyObject * const *
  function PyObject (line 2427) | PyObject * const *
  function _PyArg_CheckPositional (line 2712) | int
  function unpack_stack (line 2756) | static int
  function PyArg_UnpackTuple (line 2774) | int
  function _PyArg_UnpackStack (line 2796) | int
  function _PyArg_NoKeywords (line 2819) | int
  function _PyArg_NoPositional (line 2838) | int
  function _PyArg_NoKwnames (line 2855) | int
  function _PyArg_Fini (line 2872) | void

FILE: Generated_Cases.c.h
  function TARGET (line 6) | TARGET(NOP) {
  function TARGET (line 10) | TARGET(RESUME) {
  function TARGET (line 27) | TARGET(INSTRUMENTED_RESUME) {
  function TARGET (line 58) | TARGET(LOAD_CLOSURE) {
  function TARGET (line 71) | TARGET(LOAD_FAST_CHECK) {
  function TARGET (line 83) | TARGET(LOAD_FAST) {
  function TARGET (line 95) | TARGET(LOAD_FAST_AND_CLEAR) {
  function TARGET (line 107) | TARGET(LOAD_FAST_LOAD_FAST) {
  function TARGET (line 124) | TARGET(LOAD_CONST) {
  function TARGET (line 135) | TARGET(STORE_FAST) {
  function TARGET (line 144) | TARGET(STORE_FAST_LOAD_FAST) {
  function TARGET (line 158) | TARGET(STORE_FAST_STORE_FAST) {
  function TARGET (line 171) | TARGET(POP_TOP) {
  function TARGET (line 180) | TARGET(PUSH_NULL) {
  function TARGET (line 190) | TARGET(END_FOR) {
  function TARGET (line 209) | TARGET(INSTRUMENTED_END_FOR) {
  function TARGET (line 229) | TARGET(END_SEND) {
  function TARGET (line 240) | TARGET(INSTRUMENTED_END_SEND) {
  function TARGET (line 258) | TARGET(UNARY_NEGATIVE) {
  function TARGET (line 272) | TARGET(UNARY_NOT) {
  function TARGET (line 292) | TARGET(UNARY_INVERT) {
  function TARGET (line 306) | TARGET(BINARY_OP_MULTIPLY_INT) {
  function TARGET (line 338) | TARGET(BINARY_OP_ADD_INT) {
  function TARGET (line 370) | TARGET(BINARY_OP_SUBTRACT_INT) {
  function TARGET (line 402) | TARGET(BINARY_OP_MULTIPLY_FLOAT) {
  function TARGET (line 434) | TARGET(BINARY_OP_ADD_FLOAT) {
  function TARGET (line 466) | TARGET(BINARY_OP_SUBTRACT_FLOAT) {
  function TARGET (line 498) | TARGET(BINARY_OP_ADD_UNICODE) {
  function TARGET (line 530) | TARGET(BINARY_OP_INPLACE_ADD_UNICODE) {
  function TARGET (line 576) | TARGET(BINARY_SUBSCR) {
  function TARGET (line 606) | TARGET(BINARY_SLICE) {
  function TARGET (line 630) | TARGET(STORE_SLICE) {
  function TARGET (line 653) | TARGET(BINARY_SUBSCR_LIST_INT) {
  function TARGET (line 678) | TARGET(BINARY_SUBSCR_TUPLE_INT) {
  function TARGET (line 703) | TARGET(BINARY_SUBSCR_DICT) {
  function TARGET (line 731) | TARGET(BINARY_SUBSCR_GETITEM) {
  function TARGET (line 760) | TARGET(LIST_APPEND) {
  function TARGET (line 770) | TARGET(SET_ADD) {
  function TARGET (line 784) | TARGET(STORE_SUBSCR) {
  function TARGET (line 818) | TARGET(STORE_SUBSCR_LIST_INT) {
  function TARGET (line 845) | TARGET(STORE_SUBSCR_DICT) {
  function TARGET (line 861) | TARGET(DELETE_SUBSCR) {
  function TARGET (line 877) | TARGET(CALL_INTRINSIC_1) {
  function TARGET (line 892) | TARGET(CALL_INTRINSIC_2) {
  function TARGET (line 910) | TARGET(RAISE_VARARGS) {
  function TARGET (line 933) | TARGET(INTERPRETER_EXIT) {
  function TARGET (line 949) | TARGET(RETURN_VALUE) {
  function TARGET (line 967) | TARGET(INSTRUMENTED_RETURN_VALUE) {
  function TARGET (line 989) | TARGET(RETURN_CONST) {
  function TARGET (line 1007) | TARGET(INSTRUMENTED_RETURN_CONST) {
  function TARGET (line 1029) | TARGET(GET_AITER) {
  function TARGET (line 1072) | TARGET(GET_ANEXT) {
  function TARGET (line 1124) | TARGET(GET_AWAITABLE) {
  function TARGET (line 1158) | TARGET(SEND) {
  function TARGET (line 1217) | TARGET(SEND_GEN) {
  function TARGET (line 1239) | TARGET(INSTRUMENTED_YIELD_VALUE) {
  function TARGET (line 1261) | TARGET(YIELD_VALUE) {
  function TARGET (line 1282) | TARGET(POP_EXCEPT) {
  function TARGET (line 1292) | TARGET(RERAISE) {
  function TARGET (line 1316) | TARGET(END_ASYNC_FOR) {
  function TARGET (line 1337) | TARGET(CLEANUP_THROW) {
  function TARGET (line 1366) | TARGET(LOAD_ASSERTION_ERROR) {
  function TARGET (line 1376) | TARGET(LOAD_BUILD_CLASS) {
  function TARGET (line 1406) | TARGET(STORE_NAME) {
  function TARGET (line 1433) | TARGET(DELETE_NAME) {
  function TARGET (line 1455) | TARGET(UNPACK_SEQUENCE) {
  function TARGET (line 1483) | TARGET(UNPACK_SEQUENCE_TWO_TUPLE) {
  function TARGET (line 1501) | TARGET(UNPACK_SEQUENCE_TUPLE) {
  function TARGET (line 1520) | TARGET(UNPACK_SEQUENCE_LIST) {
  function TARGET (line 1539) | TARGET(UNPACK_EX) {
  function TARGET (line 1554) | TARGET(STORE_ATTR) {
  function TARGET (line 1587) | TARGET(DELETE_ATTR) {
  function TARGET (line 1601) | TARGET(STORE_GLOBAL) {
  function TARGET (line 1615) | TARGET(DELETE_GLOBAL) {
  function TARGET (line 1632) | TARGET(LOAD_LOCALS) {
  function TARGET (line 1652) | TARGET(LOAD_NAME) {
  function TARGET (line 1735) | TARGET(LOAD_FROM_DICT_OR_GLOBALS) {
  function TARGET (line 1804) | TARGET(LOAD_GLOBAL) {
  function TARGET (line 1870) | TARGET(LOAD_GLOBAL_MODULE) {
  function TARGET (line 1895) | TARGET(LOAD_GLOBAL_BUILTIN) {
  function TARGET (line 1925) | TARGET(DELETE_FAST) {
  function TARGET (line 1934) | TARGET(MAKE_CELL) {
  function TARGET (line 1948) | TARGET(DELETE_DEREF) {
  function TARGET (line 1964) | TARGET(LOAD_FROM_DICT_OR_DEREF) {
  function TARGET (line 2007) | TARGET(LOAD_DEREF) {
  function TARGET (line 2023) | TARGET(STORE_DEREF) {
  function TARGET (line 2035) | TARGET(COPY_FREE_VARS) {
  function TARGET (line 2051) | TARGET(BUILD_STRING) {
  function TARGET (line 2069) | TARGET(BUILD_TUPLE) {
  function TARGET (line 2082) | TARGET(BUILD_LIST) {
  function TARGET (line 2095) | TARGET(LIST_EXTEND) {
  function TARGET (line 2121) | TARGET(SET_UPDATE) {
  function TARGET (line 2135) | TARGET(BUILD_SET) {
  function TARGET (line 2160) | TARGET(BUILD_MAP) {
  function TARGET (line 2184) | TARGET(SETUP_ANNOTATIONS) {
  function TARGET (line 2229) | TARGET(BUILD_CONST_KEY_MAP) {
  function TARGET (line 2256) | TARGET(DICT_UPDATE) {
  function TARGET (line 2277) | TARGET(DICT_MERGE) {
  function TARGET (line 2295) | TARGET(MAP_ADD) {
  function TARGET (line 2309) | TARGET(INSTRUMENTED_LOAD_SUPER_ATTR) {
  function TARGET (line 2319) | TARGET(LOAD_SUPER_ATTR) {
  function TARGET (line 2387) | TARGET(LOAD_SUPER_ATTR_ATTR) {
  function TARGET (line 2415) | TARGET(LOAD_SUPER_ATTR_METHOD) {
  function TARGET (line 2452) | TARGET(LOAD_ATTR) {
  function TARGET (line 2516) | TARGET(LOAD_ATTR_INSTANCE_VALUE) {
  function TARGET (line 2544) | TARGET(LOAD_ATTR_MODULE) {
  function TARGET (line 2572) | TARGET(LOAD_ATTR_WITH_HINT) {
  function TARGET (line 2614) | TARGET(LOAD_ATTR_SLOT) {
  function TARGET (line 2639) | TARGET(LOAD_ATTR_CLASS) {
  function TARGET (line 2666) | TARGET(LOAD_ATTR_PROPERTY) {
  function TARGET (line 2698) | TARGET(LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN) {
  function TARGET (line 2732) | TARGET(STORE_ATTR_INSTANCE_VALUE) {
  function TARGET (line 2761) | TARGET(STORE_ATTR_WITH_HINT) {
  function TARGET (line 2811) | TARGET(STORE_ATTR_SLOT) {
  function TARGET (line 2832) | TARGET(COMPARE_OP) {
  function TARGET (line 2863) | TARGET(COMPARE_OP_FLOAT) {
  function TARGET (line 2885) | TARGET(COMPARE_OP_INT) {
  function TARGET (line 2911) | TARGET(COMPARE_OP_STR) {
  function TARGET (line 2934) | TARGET(IS_OP) {
  function TARGET (line 2951) | TARGET(CONTAINS_OP) {
  function TARGET (line 2969) | TARGET(CHECK_EG_MATCH) {
  function TARGET (line 3005) | TARGET(CHECK_EXC_MATCH) {
  function TARGET (line 3028) | TARGET(IMPORT_NAME) {
  function TARGET (line 3046) | TARGET(IMPORT_FROM) {
  function TARGET (line 3059) | TARGET(JUMP_FORWARD) {
  function TARGET (line 3066) | TARGET(JUMP_BACKWARD) {
  function TARGET (line 3089) | TARGET(ENTER_EXECUTOR) {
  function TARGET (line 3102) | TARGET(POP_JUMP_IF_FALSE) {
  function TARGET (line 3125) | TARGET(POP_JUMP_IF_TRUE) {
  function TARGET (line 3148) | TARGET(POP_JUMP_IF_NOT_NONE) {
  function TARGET (line 3162) | TARGET(POP_JUMP_IF_NONE) {
  function TARGET (line 3178) | TARGET(JUMP_BACKWARD_NO_INTERRUPT) {
  function TARGET (line 3190) | TARGET(GET_LEN) {
  function TARGET (line 3205) | TARGET(MATCH_CLASS) {
  function TARGET (line 3233) | TARGET(MATCH_MAPPING) {
  function TARGET (line 3245) | TARGET(MATCH_SEQUENCE) {
  function TARGET (line 3257) | TARGET(MATCH_KEYS) {
  function TARGET (line 3271) | TARGET(GET_ITER) {
  function TARGET (line 3286) | TARGET(GET_YIELD_FROM_ITER) {
  function TARGET (line 3321) | TARGET(FOR_ITER) {
  function TARGET (line 3364) | TARGET(INSTRUMENTED_FOR_ITER) {
  function TARGET (line 3395) | TARGET(FOR_ITER_LIST) {
  function TARGET (line 3425) | TARGET(FOR_ITER_TUPLE) {
  function TARGET (line 3455) | TARGET(FOR_ITER_RANGE) {
  function TARGET (line 3483) | TARGET(FOR_ITER_GEN) {
  function TARGET (line 3504) | TARGET(BEFORE_ASYNC_WITH) {
  function TARGET (line 3547) | TARGET(BEFORE_WITH) {
  function TARGET (line 3593) | TARGET(WITH_EXCEPT_START) {
  function TARGET (line 3625) | TARGET(PUSH_EXC_INFO) {
  function TARGET (line 3645) | TARGET(LOAD_ATTR_METHOD_WITH_VALUES) {
  function TARGET (line 3677) | TARGET(LOAD_ATTR_METHOD_NO_DICT) {
  function TARGET (line 3701) | TARGET(LOAD_ATTR_METHOD_LAZY_DICT) {
  function TARGET (line 3729) | TARGET(KW_NAMES) {
  function TARGET (line 3738) | TARGET(INSTRUMENTED_CALL) {
  function TARGET (line 3755) | TARGET(CALL) {
  function TARGET (line 3853) | TARGET(CALL_BOUND_METHOD_EXACT_ARGS) {
  function TARGET (line 3869) | TARGET(CALL_PY_EXACT_ARGS) {
  function TARGET (line 3904) | TARGET(CALL_PY_WITH_DEFAULTS) {
  function TARGET (line 3948) | TARGET(CALL_NO_KW_TYPE_1) {
  function TARGET (line 3971) | TARGET(CALL_NO_KW_STR_1) {
  function TARGET (line 3996) | TARGET(CALL_NO_KW_TUPLE_1) {
  function TARGET (line 4021) | TARGET(CALL_BUILTIN_CLASS) {
  function TARGET (line 4057) | TARGET(CALL_NO_KW_BUILTIN_O) {
  function TARGET (line 4099) | TARGET(CALL_NO_KW_BUILTIN_FAST) {
  function TARGET (line 4145) | TARGET(CALL_BUILTIN_FAST_WITH_KEYWORDS) {
  function TARGET (line 4191) | TARGET(CALL_NO_KW_LEN) {
  function TARGET (line 4229) | TARGET(CALL_NO_KW_ISINSTANCE) {
  function TARGET (line 4269) | TARGET(CALL_NO_KW_LIST_APPEND) {
  function TARGET (line 4294) | TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_O) {
  function TARGET (line 4338) | TARGET(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS) {
  function TARGET (line 4380) | TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS) {
  function TARGET (line 4422) | TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_FAST) {
  function TARGET (line 4463) | TARGET(INSTRUMENTED_CALL_FUNCTION_EX) {
  function TARGET (line 4469) | TARGET(CALL_FUNCTION_EX) {
  function TARGET (line 4552) | TARGET(MAKE_FUNCTION) {
  function TARGET (line 4594) | TARGET(RETURN_GENERATOR) {
  function TARGET (line 4619) | TARGET(BUILD_SLICE) {
  function TARGET (line 4639) | TARGET(FORMAT_VALUE) {
  function TARGET (line 4684) | TARGET(COPY) {
  function TARGET (line 4696) | TARGET(BINARY_OP) {
  function TARGET (line 4729) | TARGET(SWAP) {
  function TARGET (line 4740) | TARGET(INSTRUMENTED_INSTRUCTION) {
  function TARGET (line 4756) | TARGET(INSTRUMENTED_JUMP_FORWARD) {
  function TARGET (line 4763) | TARGET(INSTRUMENTED_JUMP_BACKWARD) {
  function TARGET (line 4771) | TARGET(INSTRUMENTED_POP_JUMP_IF_TRUE) {
  function TARGET (line 4785) | TARGET(INSTRUMENTED_POP_JUMP_IF_FALSE) {
  function TARGET (line 4799) | TARGET(INSTRUMENTED_POP_JUMP_IF_NONE) {
  function TARGET (line 4816) | TARGET(INSTRUMENTED_POP_JUMP_IF_NOT_NONE) {
  function TARGET (line 4833) | TARGET(EXTENDED_ARG) {
  function TARGET (line 4843) | TARGET(CACHE) {
  function TARGET (line 4850) | TARGET(RESERVED) {

FILE: GetArgs.c
  type freelistentry_t (line 34) | typedef struct {
  type freelist_t (line 39) | typedef struct {
  type _PyArg_Parser (line 64) | struct _PyArg_Parser
  type _PyArg_Parser (line 67) | struct _PyArg_Parser
  function PyArg_Parse (line 71) | int
  function _PyArg_Parse_SizeT (line 83) | PyAPI_FUNC(int)
  function PyArg_ParseTuple (line 96) | int
  function _PyArg_ParseTuple_SizeT (line 108) | int
  function _PyArg_ParseStack (line 121) | int
  function PyArg_VaParse (line 133) | int
  function _PyArg_VaParse_SizeT (line 146) | int
  function cleanup_ptr (line 162) | static int
  function cleanup_buffer (line 171) | static int
  function addcleanup (line 181) | static int
  function cleanreturn (line 195) | static int
  function vgetargs1_impl (line 215) | static int
  function vgetargs1 (line 372) | static int
  function seterror (line 399) | static void
  function _PyArg_BadArgument (line 577) | void
  function Py_ssize_t (line 1225) | static Py_ssize_t
  function getbuffer (line 1247) | static int
  function PyArg_ParseTupleAndKeywords (line 1266) | int
  function _PyArg_ParseTupleAndKeywords_SizeT (line 1290) | int
  function PyArg_VaParseTupleAndKeywords (line 1316) | int
  function _PyArg_VaParseTupleAndKeywords_SizeT (line 1341) | int
  function _PyArg_ParseTupleAndKeywordsFast (line 1367) | PyAPI_FUNC(int)
  function _PyArg_ParseTupleAndKeywordsFast_SizeT (line 1380) | int
  function _PyArg_ParseStackAndKeywords (line 1393) | int
  function _PyArg_ParseStackAndKeywords_SizeT (line 1406) | int
  function _PyArg_VaParseTupleAndKeywordsFast (line 1420) | PyAPI_FUNC(int)
  function error_unexpected_keyword_arg (line 1434) | static void
  function PyArg_ValidateKeywordArguments (line 1478) | int
  function vgetargskeywords (line 1495) | static int
  function scan_keywords (line 1779) | static int
  function parse_format (line 1800) | static int
  function PyObject (line 1881) | static PyObject *
  function _parser_init (line 1902) | static int
  function parser_init (line 1959) | static int
  function parser_clear (line 1981) | static void
  function PyObject (line 1989) | static PyObject*
  function vgetargskeywordsfast_impl (line 2015) | static int
  function vgetargskeywordsfast (line 2228) | static int
  function PyObject (line 2252) | PyObject * const *
  function PyObject (line 2427) | PyObject * const *
  function _PyArg_CheckPositional (line 2712) | int
  function unpack_stack (line 2756) | static int
  function PyArg_UnpackTuple (line 2774) | int
  function _PyArg_UnpackStack (line 2796) | int
  function _PyArg_NoKeywords (line 2819) | int
  function _PyArg_NoPositional (line 2838) | int
  function _PyArg_NoKwnames (line 2855) | int
  function _PyArg_Fini (line 2872) | void

FILE: GetOpt.c
  function _PyOS_ResetGetOpt (line 56) | void _PyOS_ResetGetOpt(void)

FILE: GetVersion.c
  function _Py_InitVersion (line 10) | void _Py_InitVersion(void)

FILE: Get_Opt.c
  function _PyOS_ResetGetOpt (line 56) | void _PyOS_ResetGetOpt(void)

FILE: Getversion.c
  function _Py_InitVersion (line 11) | void _Py_InitVersion(void)

FILE: Hamt.c
  type hamt_find_t (line 289) | typedef enum {F_ERROR, F_NOT_FOUND, F_FOUND} hamt_find_t;
  type hamt_without_t (line 301) | typedef enum {W_ERROR, W_NOT_FOUND, W_EMPTY, W_NEWNODE} hamt_without_t;
  type hamt_iter_t (line 309) | typedef enum {I_ITEM, I_END} hamt_iter_t;
  type PyHamtNode_Array (line 315) | typedef struct {
  type PyHamtNode_Collision (line 322) | typedef struct {
  function _hamt_node_array_validate (line 365) | static void
  function hamt_hash (line 388) | static inline int32_t
  function hamt_mask (line 423) | static inline uint32_t
  function hamt_bitpos (line 429) | static inline uint32_t
  function hamt_bitindex (line 435) | static inline uint32_t
  function _hamt_dump_ident (line 445) | static int
  function _hamt_dump_format (line 478) | static int
  function PyHamtNode (line 505) | static PyHamtNode *
  function Py_ssize_t (line 543) | static inline Py_ssize_t
  function PyHamtNode_Bitmap (line 549) | static PyHamtNode_Bitmap *
  function PyHamtNode_Bitmap (line 570) | static PyHamtNode_Bitmap *
  function PyHamtNode (line 600) | static PyHamtNode *
  function PyHamtNode (line 658) | static PyHamtNode *
  function hamt_without_t (line 918) | static hamt_without_t
  function hamt_find_t (line 1056) | static hamt_find_t
  function hamt_node_bitmap_traverse (line 1107) | static int
  function hamt_node_bitmap_dealloc (line 1121) | static void
  function hamt_node_bitmap_dump (line 1154) | static int
  function PyHamtNode (line 1231) | static PyHamtNode *
  function hamt_find_t (line 1260) | static hamt_find_t
  function PyHamtNode (line 1287) | static PyHamtNode *
  function Py_ssize_t (line 1391) | static inline Py_ssize_t
  function hamt_without_t (line 1397) | static hamt_without_t
  function hamt_find_t (line 1485) | static hamt_find_t
  function hamt_node_collision_traverse (line 1511) | static int
  function hamt_node_collision_dealloc (line 1526) | static void
  function hamt_node_collision_dump (line 1548) | static int
  function PyHamtNode (line 1589) | static PyHamtNode *
  function PyHamtNode_Array (line 1610) | static PyHamtNode_Array *
  function PyHamtNode (line 1633) | static PyHamtNode *
  function hamt_without_t (line 1716) | static hamt_without_t
  function hamt_find_t (line 1870) | static hamt_find_t
  function hamt_node_array_traverse (line 1890) | static int
  function hamt_node_array_dealloc (line 1905) | static void
  function hamt_node_array_dump (line 1924) | static int
  function PyHamtNode (line 1972) | static PyHamtNode *
  function hamt_without_t (line 2006) | static hamt_without_t
  function hamt_find_t (line 2033) | static hamt_find_t
  function hamt_node_dump (line 2071) | static int
  function hamt_iterator_init (line 2105) | static void
  function hamt_iter_t (line 2119) | static hamt_iter_t
  function hamt_iter_t (line 2156) | static hamt_iter_t
  function hamt_iter_t (line 2180) | static hamt_iter_t
  function hamt_iter_t (line 2221) | static hamt_iter_t
  function PyHamtObject (line 2248) | PyHamtObject *
  function PyHamtObject (line 2285) | PyHamtObject *
  function hamt_find_t (line 2326) | static hamt_find_t
  function _PyHamt_Find (line 2342) | int
  function _PyHamt_Eq (line 2359) | int
  function Py_ssize_t (line 2406) | Py_ssize_t
  function PyHamtObject (line 2412) | static PyHamtObject *
  function PyHamtObject (line 2430) | PyHamtObject *
  function PyObject (line 2439) | static PyObject *
  function hamt_baseiter_tp_clear (line 2466) | static int
  function hamt_baseiter_tp_dealloc (line 2473) | static void
  function hamt_baseiter_tp_traverse (line 2481) | static int
  function PyObject (line 2488) | static PyObject *
  function Py_ssize_t (line 2510) | static Py_ssize_t
  function PyObject (line 2520) | static PyObject *
  function PyObject (line 2558) | static PyObject *
  function PyObject (line 2564) | PyObject *
  function PyObject (line 2581) | static PyObject *
  function PyObject (line 2587) | PyObject *
  function PyObject (line 2604) | static PyObject *
  function PyObject (line 2610) | PyObject *
  function PyObject (line 2627) | static PyObject *
  function hamt_tp_clear (line 2633) | static int
  function hamt_tp_traverse (line 2641) | static int
  function hamt_tp_dealloc (line 2648) | static void
  function PyObject (line 2669) | static PyObject *
  function hamt_tp_contains (line 2693) | static int
  function PyObject (line 2700) | static PyObject *
  function Py_ssize_t (line 2718) | static Py_ssize_t
  function PyObject (line 2724) | static PyObject *
  function PyObject (line 2730) | static PyObject *
  function PyObject (line 2743) | static PyObject *
  function PyObject (line 2770) | static PyObject *
  function PyObject (line 2776) | static PyObject *
  function PyObject (line 2782) | static PyObject *
  function PyObject (line 2788) | static PyObject *
  function PyObject (line 2795) | static PyObject *

FILE: HashTable.c
  function _Py_slist_init (line 65) | static void
  function _Py_slist_prepend (line 72) | static void
  function _Py_slist_remove (line 80) | static void
  function Py_uhash_t (line 91) | Py_uhash_t
  function _Py_hashtable_compare_direct (line 98) | int
  function round_size (line 106) | static size_t
  function _Py_hashtable_size (line 119) | size_t
  function _Py_hashtable_entry_t (line 131) | _Py_hashtable_entry_t *
  function _Py_hashtable_entry_t (line 153) | static _Py_hashtable_entry_t *
  function _Py_hashtable_set (line 208) | int
  function _Py_hashtable_foreach (line 260) | int
  function hashtable_rehash (line 279) | static int
  function _Py_hashtable_t (line 315) | _Py_hashtable_t *
  function _Py_hashtable_t (line 362) | _Py_hashtable_t *
  function _Py_hashtable_destroy_entry (line 371) | static void
  function _Py_hashtable_clear (line 384) | void
  function _Py_hashtable_destroy (line 403) | void

FILE: ImPort.c
  type _inittab (line 41) | struct _inittab
  type _inittab (line 45) | struct _inittab
  type _inittab (line 48) | struct _inittab
  function _PyImport_AcquireLock (line 102) | void
  function _PyImport_ReleaseLock (line 129) | int
  function PyStatus (line 151) | PyStatus
  function PyObject (line 179) | PyObject *
  function PyObject (line 190) | PyObject *
  function _PyImport_ClearModules (line 196) | void
  function PyObject (line 202) | PyObject *
  function PyObject (line 213) | PyObject *
  function _PyImport_SetModule (line 223) | int
  function _PyImport_SetModuleString (line 231) | int
  function PyObject (line 239) | static PyObject *
  function import_ensure_initialized (line 265) | static int
  function PyObject (line 292) | PyObject *
  function PyObject (line 313) | static PyObject *
  function PyObject (line 353) | PyObject *
  function PyObject (line 371) | PyObject *
  function remove_module (line 389) | static void
  function Py_ssize_t (line 413) | Py_ssize_t
  function PyObject (line 438) | static PyObject *
  function _modules_by_index_set (line 449) | static int
  function _modules_by_index_clear_one (line 474) | static int
  function PyObject (line 487) | PyObject*
  function _PyState_AddModule (line 501) | int
  function PyState_AddModule (line 517) | int
  function PyState_RemoveModule (line 546) | int
  function _PyImport_ClearModulesByIndex (line 561) | void
  function _PyImport_GetDLOpenFlags (line 732) | int
  function _PyImport_SetDLOpenFlags (line 738) | void
  function exec_builtin_or_dynamic (line 747) | static int
  function _PyImport_ClearExtension (line 776) | int
  function extensions_lock_acquire (line 872) | static inline void
  function extensions_lock_release (line 878) | static inline void
  function _extensions_cache_init (line 900) | static void
  function PyModuleDef (line 909) | static PyModuleDef *
  function _extensions_cache_set (line 932) | static int
  function _extensions_cache_delete (line 1004) | static int
  function _extensions_cache_clear_all (line 1056) | static void
  function check_multi_interp_extensions (line 1067) | static bool
  function _PyImport_CheckSubinterpIncompatibleExtensionAllowed (line 1084) | int
  function PyObject (line 1098) | static PyObject *
  function is_core_module (line 1117) | static inline int
  function fix_up_extension (line 1133) | static int
  function _PyImport_FixupExtensionObject (line 1185) | int
  function PyObject (line 1200) | static PyObject *
  function clear_singlephase_extension (line 1261) | static int
  function _PyImport_FixupBuiltin (line 1298) | int
  function is_builtin (line 1323) | static int
  function PyObject (line 1339) | static PyObject*
  function PyImport_ExtendInittab (line 1396) | int
  function PyImport_AppendInittab (line 1446) | int
  function init_builtin_modules_table (line 1466) | static int
  function fini_builtin_modules_table (line 1484) | static void
  function PyObject (line 1492) | PyObject *
  function PyImport_GetMagicNumber (line 1523) | long
  function PyObject (line 1566) | PyObject *
  function PyObject (line 1573) | PyObject *
  function PyObject (line 1580) | PyObject *
  function PyObject (line 1633) | static PyObject *
  function PyObject (line 1659) | static PyObject *
  function PyObject (line 1682) | PyObject*
  function update_code_filenames (line 1715) | static void
  function update_compiled_module (line 1736) | static void
  function resolve_module_alias (line 1758) | static bool
  function use_frozen (line 1777) | static bool
  function PyObject (line 1793) | static PyObject *
  type frozen_status (line 1873) | typedef enum {
  function set_frozen_error (line 1884) | static inline void
  type _frozen (line 1918) | struct _frozen
  type _frozen (line 1921) | struct _frozen
  type frozen_info (line 1966) | struct frozen_info {
  function frozen_status (line 1976) | static frozen_status
  function PyObject (line 2030) | static PyObject *
  function PyImport_ImportFrozenModuleObject (line 2061) | int
  function PyImport_ImportFrozenModule (line 2137) | int
  function PyObject (line 2159) | static PyObject*
  function init_importlib (line 2213) | static int
  function init_importlib_external (line 2261) | static int
  function PyObject (line 2274) | PyObject *
  function PyObject (line 2281) | PyObject *
  function PyObject (line 2296) | PyObject *
  function PyObject (line 2311) | PyObject *
  function PyObject (line 2328) | static PyObject *
  function PyObject (line 2375) | PyObject *
  function _PyImport_InitDefaultImportFunc (line 2392) | int
  function _PyImport_IsDefaultImportFunc (line 2405) | int
  function PyObject (line 2415) | PyObject *
  function PyObject (line 2439) | PyObject *
  function remove_importlib_frames (line 2448) | static void
  function PyObject (line 2515) | static PyObject *
  function PyObject (line 2667) | static PyObject *
  function PyObject (line 2735) | PyObject *
  function PyObject (line 2879) | PyObject *
  function PyObject (line 2897) | PyObject *
  function PyObject (line 2928) | PyObject *
  function PyStatus (line 3002) | PyStatus
  function _PyImport_Fini (line 3026) | void
  function _PyImport_Fini2 (line 3042) | void
  function PyStatus (line 3064) | PyStatus
  function _PyImport_IsInitialized (line 3088) | int
  function _PyImport_ClearCore (line 3097) | void
  function _PyImport_FiniCore (line 3108) | void
  function init_zipimport (line 3136) | static int
  function PyStatus (line 3172) | PyStatus
  function _PyImport_FiniExternal (line 3192) | void
  function PyObject (line 3212) | PyObject *
  function PyObject (line 3224) | PyObject *
  function PyObject (line 3255) | static PyObject *
  function PyObject (line 3273) | static PyObject *
  function PyObject (line 3290) | static PyObject *
  function PyObject (line 3317) | static PyObject *
  function PyObject (line 3338) | static PyObject *
  function PyObject (line 3369) | static PyObject *
  function PyObject (line 3409) | static PyObject *
  function PyObject (line 3444) | static PyObject *
  function PyObject (line 3496) | static PyObject *
  function PyObject (line 3548) | static PyObject *
  function PyObject (line 3570) | static PyObject *
  function PyObject (line 3586) | static PyObject *
  function PyObject (line 3604) | static PyObject *
  function PyObject (line 3623) | static PyObject *
  function PyObject (line 3643) | static PyObject *
  function PyObject (line 3672) | static PyObject *
  function _imp_exec_dynamic_impl (line 3734) | static int
  function _imp_exec_builtin_impl (line 3753) | static int
  function PyObject (line 3767) | static PyObject *
  function imp_module_exec (line 3816) | static int
  type PyModuleDef (line 3840) | struct PyModuleDef
  function PyMODINIT_FUNC (line 3849) | PyMODINIT_FUNC

FILE: ImPortdl.c
  function PyObject (line 39) | static PyObject *
  function PyObject (line 95) | PyObject *

FILE: ImPortdl.h
  type PyObject (line 13) | typedef PyObject *(*PyModInitFunction)(void);
  type FARPROC (line 26) | typedef FARPROC dl_funcptr;

FILE: InTrinSics.c
  function PyObject (line 16) | static PyObject *
  function PyObject (line 23) | static PyObject *
  function import_all_from (line 36) | static int
  function PyObject (line 120) | static PyObject *
  function PyObject (line 142) | static PyObject *
  function PyObject (line 186) | static PyObject *
  function PyObject (line 192) | static PyObject *
  function PyObject (line 199) | static PyObject *
  function PyObject (line 226) | static PyObject *
  function PyObject (line 233) | static PyObject *
  function PyObject (line 241) | static PyObject *

FILE: InitConfig.c
  function PyObject (line 224) | static PyObject *
  function _Py_COMP_DIAG_PUSH (line 301) | _Py_COMP_DIAG_PUSH
  function PyStatus (line 312) | PyStatus PyStatus_Ok(void)
  function PyStatus (line 315) | PyStatus PyStatus_Error(const char *err_msg)
  function PyStatus (line 322) | PyStatus PyStatus_NoMemory(void)
  function PyStatus (line 325) | PyStatus PyStatus_Exit(int exitcode)
  function PyStatus_IsError (line 329) | int PyStatus_IsError(PyStatus status)
  function PyStatus_IsExit (line 332) | int PyStatus_IsExit(PyStatus status)
  function PyStatus_Exception (line 335) | int PyStatus_Exception(PyStatus status)
  function PyObject (line 338) | PyObject*
  function _PyWideStringList_CheckConsistency (line 359) | int
  function _PyWideStringList_Clear (line 374) | void
  function _PyWideStringList_Copy (line 387) | int
  function PyStatus (line 422) | PyStatus
  function PyStatus (line 463) | PyStatus
  function PyStatus (line 470) | PyStatus
  function _PyWideStringList_Find (line 483) | static int
  function PyObject (line 495) | PyObject*
  function _Py_ClearArgcArgv (line 519) | void
  function _Py_SetArgcArgv (line 531) | static int
  function Py_GetArgcArgv (line 550) | void
  function config_check_consistency (line 564) | static int
  function PyConfig_Clear (line 626) | void
  function _PyConfig_InitCompatConfig (line 669) | void
  function config_init_defaults (line 717) | static void
  function PyConfig_InitPythonConfig (line 742) | void
  function PyConfig_InitIsolatedConfig (line 753) | void
  function PyStatus (line 778) | PyStatus
  function PyStatus (line 802) | static PyStatus
  function PyStatus (line 840) | PyStatus
  function PyStatus (line 848) | PyStatus
  function PyObject (line 949) | PyObject *
  function PyObject (line 1064) | static PyObject*
  function config_dict_invalid_value (line 1076) | static void
  function config_dict_invalid_type (line 1083) | static void
  function config_dict_get_int (line 1090) | static int
  function config_dict_get_ulong (line 1112) | static int
  function config_dict_get_wstr (line 1134) | static int
  function config_dict_get_wstrlist (line 1166) | static int
  function _PyConfig_FromDict (line 1217) | int
  function PyStatus (line 1361) | static PyStatus
  function config_get_global_vars (line 1399) | static void
  function config_set_global_vars (line 1444) | static void
  function wchar_t (line 1487) | static const wchar_t*
  function wchar_t (line 1493) | static const wchar_t*
  function PyStatus (line 1505) | static PyStatus
  function config_wstr_to_int (line 1539) | static int
  function PyStatus (line 1557) | static PyStatus
  function PyStatus (line 1637) | static PyStatus
  function PyStatus (line 1658) | static PyStatus
  function PyStatus (line 1702) | static PyStatus
  function PyStatus (line 1749) | static PyStatus
  function PyStatus (line 1777) | static PyStatus
  function wchar_t (line 1829) | static const wchar_t *
  function PyStatus (line 1862) | static PyStatus
  function PyStatus (line 1882) | static PyStatus
  function PyStatus (line 1967) | static PyStatus
  function PyStatus (line 1998) | static PyStatus
  function PyStatus (line 2032) | static PyStatus
  function PyStatus (line 2065) | PyStatus
  function PyStatus (line 2072) | static PyStatus
  function config_init_stdio (line 2169) | static void
  function PyStatus (line 2210) | PyStatus
  function config_usage (line 2236) | static void
  function config_envvars_usage (line 2249) | static void
  function config_xoptions_usage (line 2255) | static void
  function config_complete_usage (line 2261) | static void
  function PyStatus (line 2273) | static PyStatus
  function PyStatus (line 2485) | static PyStatus
  function PyStatus (line 2519) | static PyStatus
  function PyStatus (line 2539) | static PyStatus
  function PyStatus (line 2556) | static PyStatus
  function PyStatus (line 2638) | static PyStatus
  function PyStatus (line 2689) | static PyStatus
  function PyStatus (line 2723) | static PyStatus
  function PyStatus (line 2753) | static PyStatus
  function PyStatus (line 2820) | PyStatus
  function PyStatus (line 2834) | PyStatus
  function PyStatus (line 2846) | PyStatus
  function PyStatus (line 2858) | PyStatus
  function PyStatus (line 2882) | PyStatus
  function PyStatus (line 2942) | PyStatus
  function PyObject (line 2949) | PyObject*
  function init_dump_ascii_wstr (line 3002) | static void
  function _Py_DumpPathConfig (line 3035) | void

FILE: InstruMenTation.c
  function opcode_has_event (line 118) | static inline bool
  function is_instrumented (line 127) | static inline bool
  function monitors_equals (line 136) | static inline bool
  function _Py_Monitors (line 148) | static inline _Py_Monitors
  function _Py_Monitors (line 159) | static inline _Py_Monitors
  function _Py_Monitors (line 170) | static inline _Py_Monitors
  function monitors_are_empty (line 180) | static inline bool
  function multiple_tools (line 191) | static inline bool
  function _PyMonitoringEventSet (line 202) | static inline _PyMonitoringEventSet
  function compute_line_delta (line 229) | static int8_t
  function compute_line (line 242) | static int
  function _PyInstruction_GetLength (line 257) | int
  function dump_instrumentation_data_tools (line 284) | static void
  function dump_instrumentation_data_lines (line 295) | static void
  function dump_instrumentation_data_line_tools (line 309) | static void
  function dump_instrumentation_data_per_instruction (line 320) | static void
  function dump_monitors (line 337) | static void
  function get_base_opcode_best_attempt (line 349) | static int
  function dump_instrumentation_data (line 380) | static void
  function valid_opcode (line 429) | static bool
  function sanity_check_instrumentation (line 443) | static void
  function _Py_GetBaseOpcode (line 532) | int _Py_GetBaseOpcode(PyCodeObject *code, int i)
  function de_instrument (line 550) | static void
  function de_instrument_line (line 578) | static void
  function de_instrument_per_instruction (line 600) | static void
  function instrument (line 626) | static void
  function instrument_line (line 655) | static void
  function instrument_per_instruction (line 669) | static void
  function instruction_has_event (line 698) | static bool
  function remove_tools (line 713) | static void
  function tools_is_subset_for_event (line 738) | static bool
  function remove_line_tools (line 747) | static void
  function add_tools (line 769) | static void
  function add_line_tools (line 789) | static void
  function add_per_instruction_tools (line 805) | static void
  function remove_per_instruction_tools (line 821) | static void
  function call_one_instrument (line 844) | static int
  function most_significant_bit (line 878) | static inline int most_significant_bit(uint8_t bits) {
  function is_version_up_to_date (line 886) | static bool
  function instrumentation_cross_checks (line 893) | static bool
  function get_tools_for_instruction (line 903) | static inline uint8_t
  function call_instrumentation_vector (line 927) | static int
  function _Py_call_instrumentation (line 981) | int
  function _Py_call_instrumentation_arg (line 990) | int
  function _Py_call_instrumentation_2args (line 999) | int
  function _Py_CODEUNIT (line 1008) | _Py_CODEUNIT *
  function call_instrumentation_vector_protected (line 1039) | static void
  function _Py_call_instrumentation_exc0 (line 1056) | void
  function _Py_call_instrumentation_exc2 (line 1066) | void
  function _Py_Instrumentation_GetLine (line 1077) | int
  function _Py_call_instrumentation_line (line 1091) | int
  function _Py_call_instrumentation_instruction (line 1160) | int
  function PyObject (line 1212) | PyObject *
  function initialize_tools (line 1223) | static void
  function initialize_lines (line 1275) | static void
  function initialize_line_tools (line 1392) | static void
  function allocate_instrumentation_data (line 1403) | static int
  function update_instrumentation_data (line 1424) | static int
  function is_super_instruction (line 1494) | static bool
  function _Py_Instrument (line 1499) | int
  function instrument_all_executing_code_objects (line 1637) | static int
  function set_events (line 1660) | static void
  function check_tool (line 1672) | static int
  function _PyMonitoring_SetEvents (line 1684) | int
  function _PyMonitoring_SetLocalEvents (line 1702) | int
  function check_valid_tool (line 1738) | static int
  function PyObject (line 1757) | static PyObject *
  function PyObject (line 1785) | static PyObject *
  function PyObject (line 1805) | static PyObject *
  function PyObject (line 1833) | static PyObject *
  function monitoring_get_events_impl (line 1868) | static int
  function PyObject (line 1889) | static PyObject *
  function monitoring_get_local_events_impl (line 1920) | static int
  function PyObject (line 1957) | static PyObject *
  function PyObject (line 1992) | static PyObject *
  function add_power2_constant (line 2009) | static int
  function PyObject (line 2044) | static PyObject *
  type PyModuleDef (line 2084) | struct PyModuleDef
  function PyObject (line 2091) | PyObject *_Py_CreateMonitoringObject(void)

FILE: InstruMentation.c
  function opcode_has_event (line 120) | static inline bool
  function is_instrumented (line 129) | static inline bool
  function monitors_equals (line 138) | static inline bool
  function _Py_Monitors (line 150) | static inline _Py_Monitors
  function _Py_Monitors (line 161) | static inline _Py_Monitors
  function _Py_Monitors (line 172) | static inline _Py_Monitors
  function monitors_are_empty (line 182) | static inline bool
  function multiple_tools (line 193) | static inline bool
  function _PyMonitoringEventSet (line 204) | static inline _PyMonitoringEventSet
  function compute_line_delta (line 231) | static int8_t
  function compute_line (line 244) | static int
  function _PyInstruction_GetLength (line 259) | int
  function dump_instrumentation_data_tools (line 286) | static void
  function dump_instrumentation_data_lines (line 297) | static void
  function dump_instrumentation_data_line_tools (line 311) | static void
  function dump_instrumentation_data_per_instruction (line 322) | static void
  function dump_monitors (line 339) | static void
  function get_base_opcode_best_attempt (line 351) | static int
  function dump_instrumentation_data (line 382) | static void
  function valid_opcode (line 431) | static bool
  function sanity_check_instrumentation (line 445) | static void
  function _Py_GetBaseOpcode (line 534) | int _Py_GetBaseOpcode(PyCodeObject *code, int i)
  function de_instrument (line 552) | static void
  function de_instrument_line (line 580) | static void
  function de_instrument_per_instruction (line 602) | static void
  function instrument (line 628) | static void
  function instrument_line (line 657) | static void
  function instrument_per_instruction (line 671) | static void
  function instruction_has_event (line 700) | static bool
  function remove_tools (line 715) | static void
  function tools_is_subset_for_event (line 740) | static bool
  function remove_line_tools (line 749) | static void
  function add_tools (line 771) | static void
  function add_line_tools (line 791) | static void
  function add_per_instruction_tools (line 807) | static void
  function remove_per_instruction_tools (line 823) | static void
  function call_one_instrument (line 846) | static int
  function most_significant_bit (line 880) | static inline int most_significant_bit(uint8_t bits) {
  function is_version_up_to_date (line 888) | static bool
  function instrumentation_cross_checks (line 895) | static bool
  function get_tools_for_instruction (line 905) | static inline uint8_t
  function call_instrumentation_vector (line 929) | static int
  function _Py_call_instrumentation (line 983) | int
  function _Py_call_instrumentation_arg (line 992) | int
  function _Py_call_instrumentation_2args (line 1001) | int
  function _Py_CODEUNIT (line 1010) | _Py_CODEUNIT *
  function call_instrumentation_vector_protected (line 1041) | static void
  function _Py_call_instrumentation_exc0 (line 1058) | void
  function _Py_call_instrumentation_exc2 (line 1068) | void
  function _Py_Instrumentation_GetLine (line 1079) | int
  function _Py_call_instrumentation_line (line 1093) | int
  function _Py_call_instrumentation_instruction (line 1162) | int
  function PyObject (line 1214) | PyObject *
  function initialize_tools (line 1225) | static void
  function initialize_lines (line 1277) | static void
  function initialize_line_tools (line 1394) | static void
  function allocate_instrumentation_data (line 1405) | static int
  function update_instrumentation_data (line 1426) | static int
  function is_super_instruction (line 1496) | static bool
  function _Py_Instrument (line 1501) | int
  function instrument_all_executing_code_objects (line 1639) | static int
  function set_events (line 1662) | static void
  function check_tool (line 1674) | static int
  function _PyMonitoring_SetEvents (line 1686) | int
  function _PyMonitoring_SetLocalEvents (line 1704) | int
  function check_valid_tool (line 1740) | static int
  function PyObject (line 1759) | static PyObject *
  function PyObject (line 1787) | static PyObject *
  function PyObject (line 1807) | static PyObject *
  function PyObject (line 1835) | static PyObject *
  function monitoring_get_events_impl (line 1870) | static int
  function PyObject (line 1891) | static PyObject *
  function monitoring_get_local_events_impl (line 1922) | static int
  function PyObject (line 1959) | static PyObject *
  function PyObject (line 1994) | static PyObject *
  function add_power2_constant (line 2011) | static int
  function PyObject (line 2046) | static PyObject *
  type PyModuleDef (line 2086) | struct PyModuleDef
  function PyObject (line 2093) | PyObject *_Py_CreateMonitoringObject(void)

FILE: Legacy_Tracing.c
  type _PyLegacyEventHandler (line 12) | typedef struct _PyLegacyEventHandler {
  function PyObject (line 25) | static PyObject *
  function PyObject (line 47) | static PyObject *
  function PyObject (line 57) | static PyObject *
  function PyObject (line 67) | static PyObject *
  function PyObject (line 99) | static PyObject *
  function PyObject (line 121) | static PyObject *
  function PyObject (line 145) | static PyObject *
  function PyObject (line 155) | static PyObject *
  function PyObject (line 169) | static PyObject *
  function PyObject (line 179) | static PyObject *
  function PyObject (line 206) | static PyObject *
  function PyObject (line 228) | static PyObject *
  function PyObject (line 254) | static PyObject *
  function set_callbacks (line 307) | static int
  function is_tstate_valid (line 330) | static int
  function _PyEval_SetProfile (line 339) | int
  function _PyEval_SetTrace (line 405) | int

FILE: MakeOpCodeTargets.py
  function find_module (line 16) | def find_module(modname):
  function write_contents (line 24) | def write_contents(f):
  function main (line 42) | def main():

FILE: MarShal.c
  type WFILE (line 83) | typedef struct {
  function w_flush (line 100) | static void
  function w_reserve (line 108) | static int
  function w_string (line 143) | static void
  function w_short (line 168) | static void
  function w_long (line 175) | static void
  function w_pstring (line 199) | static void
  function w_short_pstring (line 206) | static void
  function w_PyLong (line 229) | static void
  function w_float_bin (line 272) | static void
  function w_float_str (line 283) | static void
  function w_ref (line 295) | static int
  function w_object (line 346) | static void
  function w_complex_object (line 380) | static void
  function w_decref_entry (line 597) | static void
  function w_init_refs (line 604) | static int
  function w_clear_refs (line 619) | static void
  function PyMarshal_WriteLongToFile (line 632) | void
  function PyMarshal_WriteObjectToFile (line 647) | void
  type RFILE (line 669) | typedef struct {
  function r_byte (line 751) | static int
  function r_short (line 773) | static int
  function r_long (line 789) | static long
  function PyObject (line 810) | static PyObject *
  function PyObject (line 822) | static PyObject *
  function r_float_bin (line 897) | static double
  function Py_NO_INLINE (line 908) | Py_NO_INLINE static double
  function Py_ssize_t (line 930) | static Py_ssize_t
  function PyObject (line 954) | static PyObject *
  function PyObject (line 969) | static PyObject *
  function PyObject (line 982) | static PyObject *
  function PyObject (line 1498) | static PyObject *
  function PyMarshal_ReadShortFromFile (line 1521) | int
  function PyMarshal_ReadLongFromFile (line 1537) | long
  function off_t (line 1553) | static off_t
  function PyObject (line 1573) | PyObject *
  function PyObject (line 1598) | PyObject *
  function PyObject (line 1618) | PyObject *
  function PyObject (line 1639) | PyObject *
  function PyObject (line 1698) | static PyObject *
  function PyObject (line 1732) | static PyObject *
  function PyObject (line 1788) | static PyObject *
  function PyObject (line 1807) | static PyObject *
  function marshal_module_exec (line 1866) | static int
  type PyModuleDef (line 1881) | struct PyModuleDef
  function PyMODINIT_FUNC (line 1889) | PyMODINIT_FUNC

FILE: ModSupport.c
  type va_double (line 8) | typedef double va_double;
  function _Py_convert_optional_to_ssize_t (line 13) | int
  function Py_ssize_t (line 39) | static Py_ssize_t
  function do_ignore (line 92) | static void
  function PyObject (line 121) | static PyObject *
  function PyObject (line 171) | static PyObject *
  function do_mkstack (line 205) | static int
  function PyObject (line 242) | static PyObject *
  function PyObject (line 275) | static PyObject *
  function PyObject (line 478) | PyObject *
  function _Py_BuildValue_SizeT (line 489) | PyAPI_FUNC(PyObject *) /* abi only */
  function PyObject (line 500) | PyObject *
  function _Py_VaBuildValue_SizeT (line 506) | PyAPI_FUNC(PyObject *) /* abi only */
  function PyObject (line 512) | static PyObject *
  function PyObject (line 535) | PyObject **
  function PyModule_AddObjectRef (line 584) | int
  function PyModule_AddObject (line 617) | int
  function PyModule_AddIntConstant (line 627) | int
  function PyModule_AddStringConstant (line 639) | int
  function PyModule_AddType (line 651) | int

FILE: MySnPrintf.c
  function PyOS_snprintf (line 40) | int
  function PyOS_vsnprintf (line 52) | int

FILE: MyStrtoul.c
  function PyOS_strtoul (line 94) | unsigned long
  function PyOS_strtol (line 262) | long

FILE: OpCode_MetaData.h
  function _PyOpcode_num_popped (line 9) | int
  function _PyOpcode_num_pushed (line 405) | int
  type InstructionFormat (line 798) | enum InstructionFormat { INSTR_FMT_IB, INSTR_FMT_IBC, INSTR_FMT_IBC00, I...
  type opcode_metadata (line 799) | struct opcode_metadata {
  type opcode_metadata (line 805) | struct opcode_metadata
  type opcode_metadata (line 807) | struct opcode_metadata

FILE: OptiMizer.c
  function get_next_free_in_executor_array (line 14) | static int32_t
  function insert_executor (line 47) | static void
  function get_executor_index (line 72) | static int
  function PyUnstable_Replace_Executor (line 83) | int
  function error_optimize (line 96) | static int
  function _PyOptimizerObject (line 122) | _PyOptimizerObject *
  function PyUnstable_SetOptimizer (line 133) | void
  function _PyInterpreterFrame (line 148) | _PyInterpreterFrame *
  type _PyCounterOptimizerObject (line 174) | typedef struct {
  type _PyCounterExecutorObject (line 179) | typedef struct {
  function counter_dealloc (line 185) | static void
  function _PyInterpreterFrame (line 200) | static _PyInterpreterFrame *
  function counter_optimize (line 210) | static int
  function PyObject (line 229) | static PyObject *
  function PyObject (line 249) | PyObject *

FILE: PathConfig.c
  type _PyPathConfig (line 25) | typedef struct _PyPathConfig {
  function wchar_t (line 49) | const wchar_t *
  function _PyPathConfig_ClearGlobal (line 56) | void
  function PyStatus (line 83) | PyStatus
  function PyStatus (line 128) | PyStatus
  function path_out_of_memory (line 208) | static void _Py_NO_RETURN
  function Py_SetPath (line 215) | PyAPI_FUNC(void)
  function Py_SetPythonHome (line 257) | PyAPI_FUNC(void)
  function Py_SetProgramName (line 281) | PyAPI_FUNC(void)
  function wchar_t (line 304) | wchar_t *
  function wchar_t (line 316) | wchar_t *
  function wchar_t (line 327) | wchar_t *
  function wchar_t (line 334) | wchar_t *
  function wchar_t (line 341) | wchar_t *
  function wchar_t (line 348) | wchar_t*
  function wchar_t (line 355) | wchar_t *
  function _PyPathConfig_ComputeSysPath0 (line 374) | int

FILE: Perf_Trampoline.c
  function invalidate_icache (line 154) | static void invalidate_icache(char* begin, char*end) {
  type PyObject (line 167) | typedef PyObject *(*py_evaluator)(PyThreadState *, _PyInterpreterFrame *,
  type PyObject (line 169) | typedef PyObject *(*py_trampoline)(PyThreadState *, _PyInterpreterFrame ...
  type code_arena_st (line 177) | struct code_arena_st {
  type code_arena_t (line 187) | typedef struct code_arena_st code_arena_t;
  type trampoline_api_t (line 188) | typedef struct trampoline_api_st trampoline_api_t;
  function perf_map_write_entry (line 197) | static void
  function new_code_arena (line 225) | static int
  function free_code_arenas (line 294) | static void
  function py_trampoline (line 308) | static inline py_trampoline
  function py_trampoline (line 317) | static inline py_trampoline
  function PyObject (line 330) | static PyObject *
  function _PyIsPerfTrampolineActive (line 363) | int
  function _PyPerfTrampoline_GetCallbacks (line 373) | void
  function _PyPerfTrampoline_SetCallbacks (line 387) | int
  function _PyPerfTrampoline_Init (line 406) | int
  function _PyPerfTrampoline_Fini (line 436) | int
  function PyStatus (line 450) | PyStatus

FILE: PreConfig.c
  function _Py_ClearFileSystemEncoding (line 24) | void
  function _Py_SetFileSystemEncoding (line 46) | int
  function PyStatus (line 77) | PyStatus
  function _PyPreCmdline_Clear (line 115) | void
  function PyStatus (line 123) | PyStatus
  function precmdline_get_preconfig (line 130) | static void
  function precmdline_set_preconfig (line 146) | static void
  function PyStatus (line 160) | PyStatus
  function PyStatus (line 182) | static PyStatus
  function PyStatus (line 229) | PyStatus
  function _PyPreConfig_InitCompatConfig (line 282) | void
  function PyPreConfig_InitPythonConfig (line 310) | void
  function PyPreConfig_InitIsolatedConfig (line 331) | void
  function PyStatus (line 348) | PyStatus
  function _PyPreConfig_InitFromConfig (line 358) | void
  function preconfig_copy (line 378) | static void
  function PyObject (line 401) | PyObject*
  function _PyPreConfig_GetConfig (line 447) | void
  function preconfig_get_global_vars (line 464) | static void
  function preconfig_set_global_vars (line 498) | static void
  function _Py_str_to_int (line 544) | int
  function _Py_get_env_flag (line 562) | void
  function wchar_t (line 580) | const wchar_t*
  function PyStatus (line 601) | static PyStatus
  function preconfig_init_coerce_c_locale (line 672) | static void
  function PyStatus (line 719) | static PyStatus
  function PyStatus (line 744) | static PyStatus
  function PyStatus (line 796) | PyStatus
  function PyStatus (line 936) | PyStatus

FILE: PyArena.c
  type block (line 17) | typedef struct _block {
  type _arena (line 46) | struct _arena {
  function block (line 76) | static block *
  function block_free (line 92) | static void
  function PyArena (line 128) | PyArena *
  function _PyArena_Free (line 157) | void
  function _PyArena_AddPyObject (line 203) | int

FILE: PyFpc.c
  function PyFPE_dummy (line 14) | double

FILE: PyHash.c
  function Py_hash_t (line 91) | Py_hash_t
  function Py_hash_t (line 137) | Py_hash_t
  function Py_hash_t (line 147) | Py_hash_t
  function Py_hash_t (line 157) | Py_hash_t
  function _PyHash_Fini (line 205) | void
  function PyHash_FuncDef (line 220) | PyHash_FuncDef *
  function Py_hash_t (line 249) | static Py_hash_t
  function siphash13 (line 376) | static uint64_t
  function siphash24 (line 427) | static uint64_t
  function _Py_KeyedHash (line 477) | uint64_t
  function Py_hash_t (line 485) | static Py_hash_t
  function Py_hash_t (line 496) | static Py_hash_t

FILE: PyLifeCycle.c
  function PyStatus (line 103) | PyStatus
  function _PyRuntime_Finalize (line 120) | void
  function _Py_IsFinalizing (line 127) | int
  function _Py_IsCoreInitialized (line 143) | int
  function Py_IsInitialized (line 149) | int
  function _Py_LegacyLocaleDetected (line 176) | int
  function emit_stderr_warning_for_legacy_locale (line 209) | static void
  type _LocaleCoercionTarget (line 219) | typedef struct _CandidateLocale {
  function _Py_IsLocaleCoercionTarget (line 231) | int
  function _coerce_default_locale_settings (line 249) | static int
  function _Py_CoerceLegacyLocale (line 273) | int
  function interpreter_update_config (line 382) | static int
  function _PyInterpreterState_SetConfig (line 413) | int
  function PyStatus (line 459) | static PyStatus
  function PyStatus (line 497) | static PyStatus
  function PyStatus (line 546) | static PyStatus
  function PyStatus (line 585) | static PyStatus
  function PyStatus (line 611) | static PyStatus
  function PyStatus (line 660) | static PyStatus
  function PyStatus (line 678) | static PyStatus
  function PyStatus (line 745) | static PyStatus
  function PyStatus (line 805) | static PyStatus
  function PyStatus (line 869) | static PyStatus
  function PyStatus (line 897) | PyStatus
  function PyStatus (line 944) | PyStatus
  function PyStatus (line 952) | PyStatus
  function PyStatus (line 960) | PyStatus
  function PyStatus (line 967) | PyStatus
  function PyStatus (line 1021) | static PyStatus
  function PyStatus (line 1067) | static PyStatus
  function PyStatus (line 1077) | static PyStatus
  function PyStatus (line 1209) | static PyStatus
  function PyStatus (line 1229) | PyStatus
  function Py_InitializeEx (line 1262) | void
  function Py_Initialize (line 1290) | void
  function PyStatus (line 1297) | PyStatus
  function finalize_modules_delete_special (line 1309) | static void
  function PyObject (line 1366) | static PyObject*
  function finalize_clear_modules_dict (line 1438) | static void
  function finalize_restore_builtins (line 1452) | static void
  function finalize_modules_clear_weaklist (line 1468) | static void
  function finalize_clear_sys_builtins_dict (line 1495) | static void
  function finalize_modules (line 1514) | static void
  function file_is_closed (line 1597) | static int
  function flush_std_files (line 1614) | static int
  function finalize_interp_types (line 1661) | static void
  function finalize_interp_clear (line 1697) | static void
  function finalize_interp_delete (line 1727) | static void
  function Py_FinalizeEx (line 1743) | int
  function Py_Finalize (line 1972) | void
  function PyStatus (line 1992) | static PyStatus
  function PyStatus (line 2097) | PyStatus
  function PyThreadState (line 2104) | PyThreadState *
  function Py_EndInterpreter (line 2128) | void
  function _Py_IsInterpreterFinalizing (line 2164) | int
  function PyStatus (line 2178) | static PyStatus
  function PyStatus (line 2233) | static PyStatus
  function is_valid_fd (line 2247) | static int
  function PyObject (line 2294) | static PyObject*
  function PyStatus (line 2434) | static PyStatus
  function PyStatus (line 2467) | static PyStatus
  function _Py_FatalError_DumpTracebacks (line 2564) | static void
  function _Py_FatalError_PrintExc (line 2582) | static int
  function fatal_output_debug (line 2621) | static void
  function fatal_error_dump_runtime (line 2656) | static void
  function fatal_error_exit (line 2685) | static inline void _Py_NO_RETURN
  function _Py_DumpExtensionModules (line 2706) | void
  function fatal_error (line 2794) | static void _Py_NO_RETURN
  function Py_FatalError (line 2879) | void _Py_NO_RETURN
  function _Py_FatalErrorFunc (line 2886) | void _Py_NO_RETURN
  function _Py_FatalErrorFormat (line 2893) | void _Py_NO_RETURN
  function _Py_FatalRefcountErrorFunc (line 2923) | void _Py_NO_RETURN
  function Py_ExitStatusException (line 2933) | void _Py_NO_RETURN
  function wait_for_thread_shutdown (line 2952) | static void
  function Py_AtExit (line 2974) | int Py_AtExit(void (*func)(void))
  function call_ll_exitfuncs (line 2982) | static void
  function Py_Exit (line 2999) | void _Py_NO_RETURN
  function Py_FdIsInteractive (line 3016) | int
  function _Py_FdIsInteractive (line 3031) | int
  function PyOS_sighandler_t (line 3048) | PyOS_sighandler_t
  function PyOS_sighandler_t (line 3087) | PyOS_sighandler_t

FILE: PyMath.c
  function _Py_get_387controlword (line 8) | __attribute__((no_sanitize_memory))
  function _Py_set_387controlword (line 16) | void _Py_set_387controlword(unsigned short cw) {

FILE: PyState.c
  function PyThreadState (line 68) | static inline PyThreadState *
  function current_fast_set (line 79) | static inline void
  function current_fast_clear (line 91) | static inline void
  function PyThreadState (line 107) | PyThreadState *
  function tstate_tss_initialized (line 118) | static inline int
  function tstate_tss_init (line 124) | static inline int
  function tstate_tss_fini (line 131) | static inline void
  function PyThreadState (line 138) | static inline PyThreadState *
  function tstate_tss_set (line 145) | static inline int
  function tstate_tss_clear (line 153) | static inline int
  function PyStatus (line 165) | static PyStatus
  function gilstate_tss_set (line 209) | static inline void
  function gilstate_tss_clear (line 218) | static inline void
  function tstate_is_bound (line 230) | static inline int
  function bind_tstate (line 240) | static void
  function unbind_tstate (line 263) | static void
  function bind_gilstate_tstate (line 304) | static void
  function unbind_gilstate_tstate (line 324) | static void
  function holds_gil (line 351) | static int
  function alloc_for_runtime (line 385) | static int
  function init_runtime (line 409) | static void
  function PyStatus (line 450) | PyStatus
  function _PyRuntimeState_Fini (line 490) | void
  function PyStatus (line 533) | PyStatus
  function PyStatus (line 593) | PyStatus
  function PyInterpreterState (line 620) | static PyInterpreterState *
  function free_interpreter (line 626) | static void
  function init_interpreter (line 655) | static void
  function PyInterpreterState (line 706) | PyInterpreterState *
  function interpreter_clear (line 791) | static void
  function PyInterpreterState_Clear (line 913) | void
  function _PyInterpreterState_Clear (line 925) | void
  function PyInterpreterState_Delete (line 935) | void
  function PyStatus (line 995) | PyStatus
  function PyInterpreterState_GetID (line 1042) | int64_t
  function _PyInterpreterState_IDInitref (line 1053) | int
  function _PyInterpreterState_IDIncref (line 1070) | int
  function _PyInterpreterState_IDDecref (line 1084) | void
  function _PyInterpreterState_RequiresIDRef (line 1106) | int
  function _PyInterpreterState_RequireIDRef (line 1112) | void
  function PyObject (line 1118) | PyObject *
  function PyObject (line 1129) | PyObject *
  function PyInterpreterState (line 1152) | PyInterpreterState *
  function PyInterpreterState (line 1165) | static PyInterpreterState *
  function PyInterpreterState (line 1186) | PyInterpreterState *
  function tstate_is_alive (line 1209) | static inline int
  function _PyStackChunk (line 1227) | static _PyStackChunk*
  function PyThreadState (line 1241) | static PyThreadState *
  function free_threadstate (line 1247) | static void
  function init_threadstate (line 1265) | static void
  function add_threadstate (line 1304) | static void
  function PyThreadState (line 1320) | static PyThreadState *
  function PyThreadState (line 1371) | PyThreadState *
  function PyThreadState (line 1387) | PyThreadState *
  function PyThreadState (line 1394) | PyThreadState *
  function _PyThreadState_Init (line 1402) | void
  function clear_datastack (line 1409) | static void
  function PyThreadState_Clear (line 1421) | void
  function tstate_delete_common (line 1504) | static void
  function zapthreads (line 1540) | static void
  function PyThreadState_Delete (line 1554) | void
  function _PyThreadState_DeleteCurrent (line 1564) | void
  function PyThreadState_DeleteCurrent (line 1574) | void
  function _PyThreadState_DeleteExcept (line 1589) | void
  function _PyThreadState_InitDetached (line 1630) | void
  function _PyThreadState_ClearDetached (line 1644) | void
  function _PyThreadState_BindDetached (line 1659) | void
  function _PyThreadState_UnbindDetached (line 1669) | void
  function PyObject (line 1705) | PyObject *
  function PyObject (line 1719) | PyObject *
  function PyInterpreterState (line 1730) | PyInterpreterState *
  function PyFrameObject (line 1738) | PyFrameObject*
  function PyThreadState_GetID (line 1754) | uint64_t
  function tstate_activate (line 1762) | static inline void
  function tstate_deactivate (line 1779) | static inline void
  function PyThreadState_SetAsyncExc (line 1808) | int
  function PyThreadState (line 1850) | PyThreadState *
  function PyThreadState (line 1857) | PyThreadState *
  function _swap_thread_states (line 1866) | static void
  function PyThreadState (line 1886) | PyThreadState *
  function PyThreadState (line 1905) | PyThreadState *
  function PyThreadState (line 1919) | PyThreadState *
  function _PyThreadState_Bind (line 1926) | void
  function PyInterpreterState (line 1945) | PyInterpreterState *
  function PyInterpreterState (line 1951) | PyInterpreterState *
  function PyInterpreterState (line 1957) | PyInterpreterState *
  function PyThreadState (line 1962) | PyThreadState *
  function PyThreadState (line 1967) | PyThreadState *
  function PyObject (line 1982) | PyObject *
  function PyObject (line 2043) | PyObject *
  function PyStatus (line 2109) | PyStatus
  function _PyGILState_Fini (line 2124) | void
  function PyStatus (line 2137) | PyStatus
  function PyInterpreterState (line 2161) | PyInterpreterState *
  function PyThreadState (line 2169) | PyThreadState *
  function PyGILState_Check (line 2179) | int
  function PyGILState_STATE (line 2199) | PyGILState_STATE
  function PyGILState_Release (line 2250) | void
  function _xidata_init (line 2303) | static inline void
  function _xidata_clear (line 2314) | static inline void
  function _PyCrossInterpreterData_Init (line 2324) | void
  function _PyCrossInterpreterData_InitWithSize (line 2346) | int
  function _PyCrossInterpreterData_Clear (line 2365) | void
  function _check_xidata (line 2375) | static int
  function crossinterpdatafunc (line 2401) | static crossinterpdatafunc
  function _PyObject_CheckCrossInterpreterData (line 2411) | int
  function _PyObject_GetCrossInterpreterData (line 2421) | int
  function PyObject (line 2459) | PyObject *
  function _call_in_interpreter (line 2467) | static void
  function _PyCrossInterpreterData_Release (line 2493) | int
  function _xidregistry_add_type (line 2524) | static int
  type _xidregitem (line 2550) | struct _xidregitem
  type _xidregistry (line 2551) | struct _xidregistry
  type _xidregitem (line 2552) | struct _xidregitem
  type _xidregitem (line 2554) | struct _xidregitem
  type _xidregitem (line 2571) | struct _xidregitem
  type _xidregistry (line 2572) | struct _xidregistry
  type _xidregitem (line 2574) | struct _xidregitem
  type _xidregistry (line 2592) | struct _xidregistry
  function _PyCrossInterpreterData_RegisterClass (line 2594) | int
  function _PyCrossInterpreterData_UnregisterClass (line 2617) | int
  function crossinterpdatafunc (line 2637) | crossinterpdatafunc
  type _shared_bytes_data (line 2655) | struct _shared_bytes_data {
  function PyObject (line 2660) | static PyObject *
  function _bytes_shared (line 2667) | static int
  type _shared_str_data (line 2686) | struct _shared_str_data {
  function PyObject (line 2692) | static PyObject *
  function _str_shared (line 2699) | static int
  function PyObject (line 2717) | static PyObject *
  function _long_shared (line 2723) | static int
  function PyObject (line 2744) | static PyObject *
  function _none_shared (line 2751) | static int
  function _register_builtins_for_crossinterpreter_data (line 2761) | static void
  function _PyFrameEvalFunction (line 2786) | _PyFrameEvalFunction
  function _PyInterpreterState_SetEvalFrameFunc (line 2796) | void
  function PyConfig (line 2809) | const PyConfig*
  function _PyInterpreterState_GetConfigCopy (line 2816) | int
  function PyConfig (line 2830) | const PyConfig*
  function _PyInterpreterState_HasFeature (line 2841) | int
  function PyObject (line 2850) | static PyObject **
  function _PyInterpreterFrame (line 2875) | _PyInterpreterFrame *
  function _PyThreadState_PopFrame (line 2887) | void

FILE: PyStrcmp.c
  function PyOS_mystrnicmp (line 6) | int
  function PyOS_mystricmp (line 21) | int

FILE: PyStrhex.c
  function PyObject (line 7) | static PyObject *_Py_strhex_impl(const char* argbuf, const Py_ssize_t ar...
  function PyObject (line 148) | PyObject * _Py_strhex(const char* argbuf, const Py_ssize_t arglen)
  function PyObject (line 155) | PyObject* _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen)
  function PyObject (line 162) | PyObject* _Py_strhex_with_sep(const char* argbuf, const Py_ssize_t arglen,
  function PyObject (line 170) | PyObject* _Py_strhex_bytes_with_sep(const char* argbuf, const Py_ssize_t...

FILE: PyStrtod.c
  function case_insensitive_match (line 11) | static int
  function _Py_parse_inf_or_nan (line 26) | double
  function _PyOS_ascii_strtod (line 91) | static double
  function _PyOS_ascii_strtod (line 124) | static double
  function PyOS_string_to_double (line 297) | double
  function PyObject (line 343) | PyObject *
  function change_decimal_from_locale_to_dot (line 408) | Py_LOCAL_INLINE(void)
  function ensure_minimum_exponent_length (line 446) | Py_LOCAL_INLINE(void)
  function remove_trailing_zeros (line 514) | Py_LOCAL_INLINE(void)
  function ensure_decimal_point (line 560) | Py_LOCAL_INLINE(char *)

FILE: PyTime.c
  function pytime_time_t_overflow (line 52) | static void
  function pytime_overflow (line 60) | static void
  function _PyTime_t (line 68) | static inline _PyTime_t
  function _PyTime_t (line 76) | static inline _PyTime_t
  function pytime_add (line 85) | static inline int
  function _PyTime_t (line 103) | _PyTime_t
  function pytime_mul_check_overflow (line 111) | static inline int
  function pytime_mul (line 125) | static inline int
  function _PyTime_t (line 141) | static inline _PyTime_t
  function _PyTime_t (line 151) | _PyTime_t
  function time_t (line 168) | time_t
  function PyObject (line 188) | PyObject *
  function _PyTime_AsTime_t (line 203) | static int
  function _PyTime_AsLong (line 224) | static int
  function pytime_round_half_even (line 245) | static double
  function pytime_round (line 257) | static double
  function pytime_double_to_denominator (line 281) | static int
  function pytime_object_to_denominator (line 329) | static int
  function _PyTime_ObjectToTime_t (line 356) | int
  function _PyTime_ObjectToTimespec (line 391) | int
  function _PyTime_ObjectToTimeval (line 399) | int
  function _PyTime_t (line 407) | _PyTime_t
  function _PyTime_t (line 424) | _PyTime_t
  function _PyTime_t (line 431) | _PyTime_t
  function _PyTime_FromNanosecondsObject (line 439) | int
  function pytime_fromtimespec (line 466) | static int
  function _PyTime_FromTimespec (line 489) | int
  function pytime_fromtimeval (line 498) | static int
  function _PyTime_FromTimeval (line 520) | int
  function pytime_from_double (line 528) | static int
  function pytime_from_object (line 552) | static int
  function _PyTime_FromSecondsObject (line 588) | int
  function _PyTime_FromMillisecondsObject (line 595) | int
  function _PyTime_AsSecondsDouble (line 602) | double
  function PyObject (line 623) | PyObject *
  function _PyTime_t (line 633) | static _PyTime_t
  function _PyTime_t (line 658) | static _PyTime_t
  function pytime_divmod (line 704) | static int
  function _PyTime_t (line 728) | _PyTime_t
  function _PyTime_t (line 736) | _PyTime_t
  function _PyTime_t (line 745) | _PyTime_t
  function _PyTime_t (line 753) | _PyTime_t
  function pytime_as_timeval (line 761) | static int
  function pytime_as_timeval_struct (line 776) | static int
  function _PyTime_AsTimeval (line 803) | int
  function _PyTime_AsTimeval_clamp (line 810) | void
  function _PyTime_AsTimevalTime_t (line 817) | int
  function pytime_as_timespec (line 836) | static int
  function _PyTime_AsTimespec_clamp (line 856) | void
  function _PyTime_AsTimespec (line 862) | int
  type timespec (line 906) | struct timespec
  type timeval (line 910) | struct timeval
  type timespec (line 931) | struct timespec
  type timezone (line 953) | struct timezone
  function _PyTime_t (line 981) | _PyTime_t
  function _PyTime_GetSystemClockWithInfo (line 994) | int
  function py_mach_timebase_info (line 1002) | static int
  function py_get_monotonic_clock (line 1053) | static int
  function _PyTime_t (line 1178) | _PyTime_t
  function _PyTime_GetMonotonicClockWithInfo (line 1191) | int
  function py_win_perf_counter_frequency (line 1199) | static int
  function py_get_win_perf_counter (line 1235) | static int
  function _PyTime_GetPerfCounterWithInfo (line 1272) | int
  function _PyTime_t (line 1283) | _PyTime_t
  function _PyTime_localtime (line 1302) | int
  function _PyTime_gmtime (line 1341) | int
  function _PyTime_t (line 1369) | _PyTime_t
  function _PyTime_t (line 1377) | _PyTime_t

FILE: Python-AST.c
  type ast_state (line 13) | struct ast_state
  type ast_state (line 15) | struct ast_state
  type ast_state (line 19) | struct ast_state
  function _PyAST_Fini (line 26) | void _PyAST_Fini(PyInterpreterState *interp)
  function init_identifiers (line 282) | static int init_identifiers(struct ast_state *state)
  type ast_state (line 388) | struct ast_state
  type ast_state (line 409) | struct ast_state
  type ast_state (line 544) | struct ast_state
  type ast_state (line 657) | struct ast_state
  type ast_state (line 658) | struct ast_state
  type ast_state (line 659) | struct ast_state
  type ast_state (line 660) | struct ast_state
  type ast_state (line 661) | struct ast_state
  type ast_state (line 662) | struct ast_state
  type ast_state (line 675) | struct ast_state
  type ast_state (line 681) | struct ast_state
  type ast_state (line 691) | struct ast_state
  type ast_state (line 703) | struct ast_state
  type ast_state (line 714) | struct ast_state
  type ast_state (line 725) | struct ast_state
  type ast_state (line 730) | struct ast_state
  type ast_state (line 742) | struct ast_state
  type ast_state (line 773) | struct ast_state
  type ast_state (line 784) | struct ast_state
  type AST_object (line 798) | typedef struct {
  function ast_dealloc (line 803) | static void
  function ast_traverse (line 816) | static int
  function ast_clear (line 824) | static int
  function ast_type_init (line 831) | static int
  function PyObject (line 907) | static PyObject *
  function PyObject (line 964) | static PyObject *
  function add_attributes (line 991) | static int
  function PyObject (line 1013) | static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq, Py...
  function PyObject (line 1031) | static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void...
  function PyObject (line 1043) | static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), long b)
  function obj2ast_object (line 1050) | static int obj2ast_object(struct ast_state *Py_UNUSED(state), PyObject* ...
  function obj2ast_constant (line 1067) | static int obj2ast_constant(struct ast_state *Py_UNUSED(state), PyObject...
  function obj2ast_identifier (line 1077) | static int obj2ast_identifier(struct ast_state *state, PyObject* obj, Py...
  function obj2ast_string (line 1086) | static int obj2ast_string(struct ast_state *state, PyObject* obj, PyObje...
  function obj2ast_int (line 1095) | static int obj2ast_int(struct ast_state* Py_UNUSED(state), PyObject* obj...
  function add_ast_fields (line 1110) | static int add_ast_fields(struct ast_state *state)
  function init_types (line 1127) | static int
  type ast_state (line 1934) | struct ast_state
  type ast_state (line 1936) | struct ast_state
  type ast_state (line 1938) | struct ast_state
  type ast_state (line 1940) | struct ast_state
  type ast_state (line 1942) | struct ast_state
  type ast_state (line 1944) | struct ast_state
  type ast_state (line 1946) | struct ast_state
  type ast_state (line 1948) | struct ast_state
  type ast_state (line 1950) | struct ast_state
  type ast_state (line 1952) | struct ast_state
  type ast_state (line 1954) | struct ast_state
  type ast_state (line 1956) | struct ast_state
  type ast_state (line 1958) | struct ast_state
  type ast_state (line 1960) | struct ast_state
  type ast_state (line 1962) | struct ast_state
  type ast_state (line 1964) | struct ast_state
  type ast_state (line 1966) | struct ast_state
  type ast_state (line 1968) | struct ast_state
  type ast_state (line 1970) | struct ast_state
  function mod_ty (line 1973) | mod_ty
  function mod_ty (line 1987) | mod_ty
  function mod_ty (line 1999) | mod_ty
  function mod_ty (line 2016) | mod_ty
  function stmt_ty (line 2034) | stmt_ty
  function stmt_ty (line 2070) | stmt_ty
  function stmt_ty (line 2106) | stmt_ty
  function stmt_ty (line 2135) | stmt_ty
  function stmt_ty (line 2152) | stmt_ty
  function stmt_ty (line 2169) | stmt_ty
  function stmt_ty (line 2194) | stmt_ty
  function stmt_ty (line 2224) | stmt_ty
  function stmt_ty (line 2258) | stmt_ty
  function stmt_ty (line 2289) | stmt_ty
  function stmt_ty (line 2321) | stmt_ty
  function stmt_ty (line 2353) | stmt_ty
  function stmt_ty (line 2378) | stmt_ty
  function stmt_ty (line 2403) | stmt_ty
  function stmt_ty (line 2423) | stmt_ty
  function stmt_ty (line 2443) | stmt_ty
  function stmt_ty (line 2466) | stmt_ty
  function stmt_ty (line 2484) | stmt_ty
  function stmt_ty (line 2505) | stmt_ty
  function stmt_ty (line 2527) | stmt_ty
  function stmt_ty (line 2550) | stmt_ty
  function stmt_ty (line 2567) | stmt_ty
  function stmt_ty (line 2587) | stmt_ty
  function stmt_ty (line 2604) | stmt_ty
  function stmt_ty (line 2621) | stmt_ty
  function stmt_ty (line 2643) | stmt_ty
  function stmt_ty (line 2659) | stmt_ty
  function stmt_ty (line 2675) | stmt_ty
  function expr_ty (line 2691) | expr_ty
  function expr_ty (line 2714) | expr_ty
  function expr_ty (line 2742) | expr_ty
  function expr_ty (line 2776) | expr_ty
  function expr_ty (line 2804) | expr_ty
  function expr_ty (line 2832) | expr_ty
  function expr_ty (line 2866) | expr_ty
  function expr_ty (line 2884) | expr_ty
  function expr_ty (line 2901) | expr_ty
  function expr_ty (line 2925) | expr_ty
  function expr_ty (line 2949) | expr_ty
  function expr_ty (line 2979) | expr_ty
  function expr_ty (line 3003) | expr_ty
  function expr_ty (line 3025) | expr_ty
  function expr_ty (line 3042) | expr_ty
  function expr_ty (line 3064) | expr_ty
  function expr_ty (line 3089) | expr_ty
  function expr_ty (line 3114) | expr_ty
  function expr_ty (line 3139) | expr_ty
  function expr_ty (line 3156) | expr_ty
  function expr_ty (line 3179) | expr_ty
  function expr_ty (line 3214) | expr_ty
  function expr_ty (line 3249) | expr_ty
  function expr_ty (line 3277) | expr_ty
  function expr_ty (line 3305) | expr_ty
  function expr_ty (line 3328) | expr_ty
  function expr_ty (line 3351) | expr_ty
  function comprehension_ty (line 3370) | comprehension_ty
  function excepthandler_ty (line 3395) | excepthandler_ty
  function arguments_ty (line 3415) | arguments_ty
  function arg_ty (line 3435) | arg_ty
  function keyword_ty (line 3458) | keyword_ty
  function alias_ty (line 3480) | alias_ty
  function withitem_ty (line 3502) | withitem_ty
  function match_case_ty (line 3519) | match_case_ty
  function pattern_ty (line 3538) | pattern_ty
  function pattern_ty (line 3560) | pattern_ty
  function pattern_ty (line 3582) | pattern_ty
  function pattern_ty (line 3599) | pattern_ty
  function pattern_ty (line 3619) | pattern_ty
  function pattern_ty (line 3646) | pattern_ty
  function pattern_ty (line 3663) | pattern_ty
  function pattern_ty (line 3681) | pattern_ty
  function type_ignore_ty (line 3698) | type_ignore_ty
  function type_param_ty (line 3716) | type_param_ty
  function type_param_ty (line 3739) | type_param_ty
  function type_param_ty (line 3761) | type_param_ty
  function PyObject (line 3784) | PyObject*
  function PyObject (line 3861) | PyObject*
  function PyObject (line 4466) | PyObject*
  function PyObject (line 4949) | PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty o)
  function PyObject (line 4961) | PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty o)
  function PyObject (line 4971) | PyObject* ast2obj_operator(struct ast_state *state, operator_ty o)
  function PyObject (line 5003) | PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty o)
  function PyObject (line 5017) | PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty o)
  function PyObject (line 5043) | PyObject*
  function PyObject (line 5088) | PyObject*
  function PyObject (line 5153) | PyObject*
  function PyObject (line 5213) | PyObject*
  function PyObject (line 5273) | PyObject*
  function PyObject (line 5328) | PyObject*
  function PyObject (line 5383) | PyObject*
  function PyObject (line 5418) | PyObject*
  function PyObject (line 5458) | PyObject*
  function PyObject (line 5619) | PyObject*
  function PyObject (line 5658) | PyObject*
  function obj2ast_mod (line 5738) | int
  function obj2ast_stmt (line 5985) | int
  function obj2ast_expr (line 8564) | int
  function obj2ast_expr_context (line 10310) | int
  function obj2ast_boolop (line 10345) | int
  function obj2ast_operator (line 10372) | int
  function obj2ast_unaryop (line 10487) | int
  function obj2ast_cmpop (line 10530) | int
  function obj2ast_comprehension (line 10621) | int
  function obj2ast_excepthandler (line 10725) | int
  function obj2ast_arguments (line 10902) | int
  function obj2ast_arg (line 11137) | int
  function obj2ast_keyword (line 11276) | int
  function obj2ast_alias (line 11398) | int
  function obj2ast_withitem (line 11520) | int
  function obj2ast_match_case (line 11569) | int
  function obj2ast_pattern (line 11655) | int
  function obj2ast_type_ignore (line 12229) | int
  function obj2ast_type_param (line 12296) | int
  function astmodule_exec (line 12497) | static int
  type PyModuleDef (line 12906) | struct PyModuleDef
  function PyMODINIT_FUNC (line 12914) | PyMODINIT_FUNC
  function PyObject (line 12921) | PyObject* PyAST_mod2obj(mod_ty t)
  function mod_ty (line 12953) | mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
  function PyAST_Check (line 12990) | int PyAST_Check(PyObject* obj)

FILE: Python-Tokenize.c
  type PyModuleDef (line 7) | struct PyModuleDef
  type tokenize_state (line 9) | typedef struct {
  function tokenize_state (line 13) | static tokenize_state *
  type tokenizeriterobject (line 30) | typedef struct
  function PyObject (line 47) | static PyObject *
  function _tokenizer_error (line 73) | static int
  function PyObject (line 171) | static PyObject *
  function tokenizeriter_dealloc (line 264) | static void
  function tokenizemodule_exec (line 289) | static int
  function tokenizemodule_traverse (line 318) | static int
  function tokenizemodule_clear (line 326) | static int
  function tokenizemodule_free (line 334) | static void
  type PyModuleDef (line 340) | struct PyModuleDef
  function PyMODINIT_FUNC (line 351) | PyMODINIT_FUNC

FILE: PythonRun.c
  function _PyRun_AnyFileObject (line 56) | int
  function PyRun_AnyFileExFlags (line 89) | int
  function _PyRun_InteractiveLoopObject (line 110) | int
  function PyRun_InteractiveLoopFlags (line 166) | int
  function PyRun_InteractiveOneObjectEx (line 184) | static int
  function PyRun_InteractiveOneObject (line 270) | int
  function PyRun_InteractiveOneFlags (line 283) | int
  function maybe_pyc_file (line 303) | static int
  function set_main_loader (line 349) | static int
  function _PyRun_SimpleFileObject (line 375) | int
  function PyRun_SimpleFileExFlags (line 458) | int
  function PyRun_SimpleStringFlags (line 472) | int
  function parse_syntax_error (line 489) | static int
  function print_error_text (line 597) | static int
  function _Py_HandleSystemExit (line 687) | int
  function handle_system_exit (line 751) | static void
  function _PyErr_PrintEx (line 761) | static void
  function _PyErr_Print (line 835) | void
  function PyErr_PrintEx (line 841) | void
  function PyErr_Print (line 848) | void
  type exception_print_context (line 854) | struct exception_print_context
  function write_indented_margin (line 867) | static int
  function print_exception_invalid_type (line 873) | static int
  function print_exception_traceback (line 895) | static int
  function print_exception_file_and_line (line 918) | static int
  function print_exception_message (line 989) | static int
  function print_exception_suggestions (line 1073) | static int
  function print_exception_notes (line 1094) | static int
  function print_exception (line 1177) | static int
  type exception_print_context (line 1229) | struct exception_print_context
  function print_chained (line 1231) | static int
  function print_exception_seen_lookup (line 1274) | static bool
  function print_exception_cause_and_context (line 1298) | static int
  function print_exception_group (line 1338) | static int
  function print_exception_recursive (line 1465) | static int
  function _PyErr_Display (line 1497) | void
  function PyErr_Display (line 1546) | void
  function _PyErr_DisplayException (line 1564) | void _PyErr_DisplayException(PyObject *file, PyObject *exc)
  function PyErr_DisplayException (line 1569) | void PyErr_DisplayException(PyObject *exc)
  function PyObject (line 1574) | PyObject *
  function PyObject (line 1597) | static PyObject *
  function PyObject (line 1627) | PyObject *
  function flush_io_stream (line 1643) | static void
  function flush_io (line 1658) | static void
  function PyObject (line 1668) | static PyObject *
  function PyObject (line 1702) | static PyObject *
  function PyObject (line 1721) | static PyObject *
  function PyObject (line 1764) | PyObject *
  function PyObject (line 1789) | PyObject *
  function PyOS_CheckStack (line 1862) | int
  function PyRun_AnyFile (line 1891) | PyAPI_FUNC(int)
  function PyRun_AnyFileEx (line 1898) | PyAPI_FUNC(int)
  function PyRun_AnyFileFlags (line 1905) | PyAPI_FUNC(int)
  function PyRun_File (line 1912) | PyAPI_FUNC(PyObject *)
  function PyRun_FileEx (line 1919) | PyAPI_FUNC(PyObject *)
  function PyRun_FileFlags (line 1926) | PyAPI_FUNC(PyObject *)
  function PyRun_SimpleFile (line 1934) | PyAPI_FUNC(int)
  function PyRun_SimpleFileEx (line 1941) | PyAPI_FUNC(int)
  function PyRun_String (line 1949) | PyAPI_FUNC(PyObject *)
  function PyRun_SimpleString (line 1956) | PyAPI_FUNC(int)
  function Py_CompileString (line 1963) | PyAPI_FUNC(PyObject *)
  function Py_CompileStringFlags (line 1970) | PyAPI_FUNC(PyObject *)
  function PyRun_InteractiveOne (line 1978) | PyAPI_FUNC(int)
  function PyRun_InteractiveLoop (line 1985) | PyAPI_FUNC(int)

FILE: Specialize.c
  function PyObject (line 38) | static PyObject*
  function add_stat_dict (line 75) | static int
  function PyObject (line 92) | PyObject*
  function print_spec_stats (line 124) | static void
  function print_call_stats (line 162) | static void
  function print_object_stats (line 174) | static void
  function print_stats (line 200) | static void
  function _Py_StatsClear (line 207) | void
  function _Py_PrintSpecializationStats (line 213) | void
  function _PyCode_Quicken (line 269) | void
  function specialize_module_load_attr (line 468) | static int
  function _Py_Specialize_LoadSuperAttr (line 515) | void
  type DescriptorClassification (line 543) | typedef enum {
  function DescriptorClassification (line 561) | static DescriptorClassification
  function specialize_dict_access (line 660) | static int
  function _Py_Specialize_LoadAttr (line 719) | void
  function _Py_Specialize_StoreAttr (line 900) | void
  function load_attr_fail_kind (line 998) | static int
  function specialize_class_load_attr (line 1034) | static int
  function specialize_attr_loadmethod (line 1067) | static int
  function _Py_Specialize_LoadGlobal (line 1135) | void
  function binary_subscr_fail_kind (line 1236) | static int
  function function_kind (line 1275) | static int
  function function_check_args (line 1288) | static bool
  function function_get_version (line 1307) | static uint32_t
  function _Py_Specialize_BinarySubscr (line 1320) | void
  function _Py_Specialize_StoreSubscr (line 1408) | void
  function specialize_class_call (line 1513) | static int
  function builtin_call_fail_kind (line 1551) | static int
  function meth_descr_call_fail_kind (line 1574) | static int
  function specialize_method_descriptor (line 1597) | static int
  function specialize_py_call (line 1647) | static int
  function specialize_c_call (line 1697) | static int
  function call_fail_kind (line 1753) | static int
  function _Py_Specialize_Call (line 1782) | void
  function binary_op_fail_kind (line 1833) | static int
  function _Py_Specialize_BinaryOp (line 1902) | void
  function compare_op_fail_kind (line 1976) | static int
  function _Py_Specialize_CompareOp (line 2010) | void
  function unpack_sequence_fail_kind (line 2058) | static int
  function _Py_Specialize_UnpackSequence (line 2071) | void
  function _PySpecialization_ClassifyIterator (line 2111) | int
  function _Py_Specialize_ForIter (line 2184) | void
  function _Py_Specialize_Send (line 2226) | void

FILE: StrucMember.c
  function PyObject (line 7) | PyObject *
  function PyMember_SetOne (line 108) | int

FILE: Suggestions.c
  function substitution_cost (line 18) | static inline int
  function Py_ssize_t (line 41) | static Py_ssize_t
  function PyObject (line 129) | static inline PyObject *
  function PyObject (line 182) | static PyObject *
  function PyObject (line 203) | static PyObject *
  function PyObject (line 216) | static PyObject *
  function is_name_stdlib_module (line 281) | static bool
  function PyObject (line 294) | static PyObject *
  function PyObject (line 341) | static PyObject *
  function PyObject (line 376) | PyObject *
  function Py_ssize_t (line 391) | Py_ssize_t

FILE: SyMTable.c
  function PySTEntryObject (line 78) | static PySTEntryObject *
  function PyObject (line 150) | static PyObject *
  function ste_dealloc (line 158) | static void
  type symtable (line 226) | struct symtable
  type symtable (line 227) | struct symtable
  type symtable (line 231) | struct symtable
  type symtable (line 232) | struct symtable
  type symtable (line 233) | struct symtable
  type symtable (line 234) | struct symtable
  type symtable (line 235) | struct symtable
  type symtable (line 236) | struct symtable
  type symtable (line 237) | struct symtable
  type symtable (line 238) | struct symtable
  type symtable (line 239) | struct symtable
  type symtable (line 240) | struct symtable
  type symtable (line 241) | struct symtable
  type symtable (line 242) | struct symtable
  type symtable (line 243) | struct symtable
  type symtable (line 244) | struct symtable
  type symtable (line 245) | struct symtable
  type symtable (line 246) | struct symtable
  type symtable (line 247) | struct symtable
  type symtable (line 248) | struct symtable
  type symtable (line 249) | struct symtable
  type symtable (line 250) | struct symtable
  type symtable (line 251) | struct symtable
  type symtable (line 252) | struct symtable
  type symtable (line 253) | struct symtable
  type symtable (line 259) | struct symtable
  type symtable (line 262) | struct symtable
  type symtable (line 264) | struct symtable
  type symtable (line 264) | struct symtable
  type symtable (line 297) | struct symtable
  type symtable (line 300) | struct symtable
  function _PySymtable_Free (line 382) | void
  function PySTEntryObject (line 391) | PySTEntryObject *
  function _PyST_GetSymbol (line 413) | long
  function _PyST_GetScope (line 423) | int
  function _PyST_IsFunctionLike (line 430) | int
  function error_at_directive (line 439) | static int
  function analyze_name (line 528) | static int
  function is_free_in_any_child (line 627) | static int
  function inline_comprehension (line 641) | static int
  function analyze_cells (line 706) | static int
  function drop_class_free (line 739) | static int
  function update_symbols (line 760) | static int
  function analyze_block (line 877) | static int
  function analyze_child_block (line 1067) | static int
  function symtable_analyze (line 1111) | static int
  function symtable_exit_block (line 1143) | static int
  function symtable_enter_block (line 1159) | static int
  function symtable_lookup (line 1203) | static long
  function symtable_add_def_helper (line 1214) | static int
  function symtable_add_def (line 1307) | static int
  function symtable_enter_type_param_block (line 1315) | static int
  function symtable_record_directive (line 1423) | static int
  function has_kwonlydefaults (line 1445) | static int
  function symtable_visit_stmt (line 1457) | static int
  function symtable_extend_namedexpr_scope (line 1834) | static int
  function symtable_handle_namedexpr (line 1929) | static int
  function symtable_visit_expr (line 1952) | static int
  function symtable_visit_type_param (line 2112) | static int
  function symtable_visit_pattern (line 2151) | static int
  function symtable_implicit_arg (line 2201) | static int
  function symtable_visit_params (line 2215) | static int
  function symtable_visit_annotation (line 2232) | static int
  function symtable_visit_argannotations (line 2250) | static int
  function symtable_visit_annotations (line 2267) | static int
  function symtable_visit_arguments (line 2296) | static int
  function symtable_visit_excepthandler (line 2322) | static int
  function symtable_visit_withitem (line 2334) | static int
  function symtable_visit_match_case (line 2344) | static int
  function symtable_visit_alias (line 2355) | static int
  function symtable_visit_comprehension (line 2398) | static int
  function symtable_visit_keyword (line 2415) | static int
  function symtable_handle_comprehension (line 2423) | static int
  function symtable_visit_genexp (line 2486) | static int
  function symtable_visit_listcomp (line 2494) | static int
  function symtable_visit_setcomp (line 2502) | static int
  function symtable_visit_dictcomp (line 2510) | static int
  function symtable_raise_if_annotation_block (line 2519) | static int
  function symtable_raise_if_comprehension_block (line 2542) | static int
  type symtable (line 2556) | struct symtable
  type symtable (line 2560) | struct symtable
  function PyObject (line 2584) | PyObject *

FILE: SySModule.c
  function PyObject (line 66) | PyObject *
  function PyObject (line 81) | static PyObject *
  function PyObject (line 91) | PyObject *
  function sys_set_object (line 104) | static int
  function _PySys_SetAttr (line 124) | int
  function sys_set_object_str (line 131) | static int
  function PySys_SetObject (line 141) | int
  function _PySys_ClearAttrString (line 148) | int
  function should_audit (line 163) | static int
  function sys_audit_tstate (line 177) | static int
  function _PySys_Audit (line 303) | int
  function PySys_Audit (line 314) | int
  function _PySys_ClearAuditHooks (line 330) | void
  function PySys_AddAuditHook (line 365) | int
  function PyObject (line 426) | static PyObject *
  function PyObject (line 464) | static PyObject *
  function PyObject (line 514) | static PyObject *
  function sys_displayhook_unencodable (line 612) | static int
  function PyObject (line 679) | static PyObject *
  function PyObject (line 745) | static PyObject *
  function PyObject (line 765) | static PyObject *
  function PyObject (line 786) | static PyObject *
  function PyObject (line 812) | static PyObject *
  function PyObject (line 834) | static PyObject *
  function PyObject (line 851) | static PyObject *
  function PyObject (line 866) | static PyObject *
  function PyObject (line 881) | static PyObject *
  function PyObject (line 903) | static PyObject *
  function PyObject (line 936) | static PyObject *
  function profile_trampoline (line 960) | static int
  function trace_trampoline (line 975) | static int
  function PyObject (line 1007) | static PyObject *
  function PyObject (line 1043) | static PyObject *
  function PyObject (line 1069) | static PyObject *
  function PyObject (line 1081) | static PyObject *
  function PyObject (line 1117) | static PyObject *
  function PyObject (line 1142) | static PyObject *
  function PyObject (line 1171) | static PyObject *
  function sys_getswitchinterval_impl (line 1191) | static double
  function PyObject (line 1211) | static PyObject *
  function PyObject (line 1251) | static PyObject *
  function sys_get_coroutine_origin_tracking_depth_impl (line 1267) | static int
  function PyObject (line 1295) | static PyObject *
  function PyObject (line 1355) | static PyObject *
  function PyObject (line 1413) | static PyObject *
  function PyObject (line 1457) | static PyObject *
  function PyObject (line 1491) | static PyObject *
  function PyObject (line 1555) | static PyObject *
  function PyObject (line 1633) | static PyObject *
  function PyObject (line 1664) | static PyObject *
  function PyObject (line 1682) | static PyObject *
  function PyObject (line 1704) | static PyObject *
  function PyObject (line 1721) | static PyObject *
  function PyObject (line 1737) | static PyObject *
  function _PySys_GetSizeOf (line 1753) | size_t
  function PyObject (line 1796) | static PyObject *
  function Py_ssize_t (line 1842) | static Py_ssize_t
  function Py_ssize_t (line 1854) | static Py_ssize_t
  function Py_ssize_t (line 1871) | static Py_ssize_t
  function Py_ssize_t (line 1886) | static Py_ssize_t
  function PyObject (line 1910) | static PyObject *
  function PyObject (line 1948) | static PyObject *
  function PyObject (line 1963) | static PyObject *
  function PyObject (line 1984) | static PyObject *
  function PyObject (line 2005) | static PyObject *
  function PyObject (line 2035) | static PyObject *
  function PyObject (line 2052) | static PyObject *
  function PyObject (line 2066) | static PyObject *
  function PyObject (line 2080) | static PyObject *
  function PyObject (line 2094) | static PyObject *
  function PyObject (line 2108) | static PyObject *
  function PyObject (line 2126) | static PyObject *
  function PyObject (line 2143) | static PyObject *
  function PyObject (line 2181) | static PyObject *
  function PyObject (line 2197) | static PyObject *
  function PyObject (line 2224) | static PyObject *
  function PyUnstable_PerfMapState_Init (line 2253) | PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void) {
  function PyUnstable_WritePerfMapEntry (line 2281) | PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(
  function PyUnstable_PerfMapState_Fini (line 2301) | PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void) {
  function PyObject (line 2390) | static PyObject *
  function PyObject (line 2410) | static PyObject *
  type _preinit_entry (line 2450) | struct _preinit_entry {
  type _preinit_entry (line 2455) | struct _preinit_entry
  function _Py_PreInitEntry (line 2460) | static _Py_PreInitEntry
  function _append_preinit_entry (line 2485) | static int
  function _clear_preinit_entries (line 2507) | static void
  function PyStatus (line 2525) | PyStatus
  function PyStatus (line 2543) | PyStatus
  function PyObject (line 2561) | static PyObject *
  function PySys_ResetWarnOptions (line 2589) | void
  function _PySys_AddWarnOptionWithError (line 2604) | static int
  function PySys_AddWarnOptionUnicode (line 2617) | void
  function PySys_AddWarnOption (line 2629) | void
  function PySys_HasWarnOptions (line 2648) | int
  function PyObject (line 2657) | static PyObject *
  function _PySys_AddXOptionWithError (line 2685) | static int
  function PySys_AddXOption (line 2721) | void
  function PyObject (line 2735) | PyObject *
  function set_flags_from_config (line 2881) | static int
  function PyObject (line 2926) | static PyObject*
  function PyObject (line 2965) | static PyObject *
  function PyObject (line 3023) | static PyObject *
  function PyObject (line 3127) | static PyObject *
  type PyModuleDef (line 3188) | struct PyModuleDef
  function PyStatus (line 3217) | static PyStatus
  function sys_add_xoption (line 3343) | static int
  function PyObject (line 3374) | static PyObject*
  function _PySys_UpdateConfig (line 3398) | int
  function PyStatus (line 3482) | static PyStatus
  function PyStatus (line 3507) | PyStatus
  function _PySys_FiniTypes (line 3573) | void
  function PyObject (line 3591) | static PyObject *
  function PySys_SetPath (line 3624) | void
  function PyObject (line 3637) | static PyObject *
  function PySys_SetArgvEx (line 3656) | void
  function PySys_SetArgv (line 3700) | void
  function sys_pyfile_write_unicode (line 3712) | static int
  function sys_pyfile_write (line 3726) | static int
  function sys_write (line 3772) | static void
  function PySys_WriteStdout (line 3795) | void
  function PySys_WriteStderr (line 3805) | void
  function sys_format (line 3815) | static void
  function PySys_FormatStdout (line 3837) | void
  function PySys_FormatStderr (line 3847) | void

FILE: Thread.c
  function PyThread_init_thread (line 24) | void
  function PyThread_get_stacksize (line 53) | size_t
  function PyThread_set_stacksize (line 64) | int
  function Py_tss_t (line 80) | Py_tss_t *
  function PyThread_tss_free (line 91) | void
  function PyThread_tss_is_created (line 100) | int
  function PyObject (line 129) | PyObject*
  function _PyThread_FiniType (line 192) | void

FILE: Thread_NT.h
  type NRMUTEX (line 27) | typedef struct _NRMUTEX
  type NRMUTEX (line 33) | typedef NRMUTEX *PNRMUTEX;
  function PNRMUTEX (line 35) | static PNRMUTEX
  function VOID (line 54) | static VOID
  function DWORD (line 64) | static DWORD
  function BOOL (line 104) | static BOOL
  function PNRMUTEX (line 122) | static PNRMUTEX
  function VOID (line 128) | static VOID
  function DWORD (line 135) | static DWORD
  function BOOL (line 141) | static BOOL
  function PyThread__init_thread (line 157) | static void
  type callobj (line 167) | typedef struct {
  function bootstrap (line 174) | static unsigned __stdcall
  function PyThread_start_new_thread (line 185) | unsigned long
  function PyThread_get_thread_ident (line 224) | unsigned long
  function PyThread_get_thread_native_id (line 239) | unsigned long
  function PyThread_exit_thread (line 253) | PyThread_exit_thread(void)
  function PyThread_type_lock (line 265) | PyThread_type_lock
  function PyThread_free_lock (line 281) | void
  function PyLockStatus (line 298) | PyLockStatus
  function PyThread_acquire_lock (line 340) | int
  function PyThread_release_lock (line 346) | void
  function _pythread_nt_set_stacksize (line 360) | static int
  function PyThread_create_key (line 386) | int
  function PyThread_delete_key (line 395) | void
  function PyThread_set_key_value (line 401) | int
  function PyThread_delete_key_value (line 423) | void
  function PyThread_ReInitTLS (line 436) | void
  function PyThread_tss_create (line 447) | int
  function PyThread_tss_delete (line 466) | void
  function PyThread_tss_set (line 480) | int

FILE: Thread_Pthread.h
  function init_condattr (line 124) | static void
  function _PyThread_cond_init (line 139) | int
  function _PyThread_cond_after (line 146) | void
  type pthread_lock (line 180) | typedef struct {
  function PyThread__init_thread (line 194) | static void
  type pythread_callback (line 219) | typedef struct {
  function PyThread_start_new_thread (line 237) | unsigned long
  function PyThread_get_thread_ident (line 312) | unsigned long
  function PyThread_get_thread_native_id (line 323) | unsigned long
  function PyThread_exit_thread (line 355) | PyThread_exit_thread(void)
  function PyThread_type_lock (line 368) | PyThread_type_lock
  function PyThread_free_lock (line 392) | void
  function fix_status (line 415) | static int
  function PyLockStatus (line 421) | PyLockStatus
  function PyThread_release_lock (line 533) | void
  function PyThread_type_lock (line 550) | PyThread_type_lock
  function PyThread_free_lock (line 584) | void
  function PyLockStatus (line 604) | PyLockStatus
  function PyThread_release_lock (line 690) | void
  function _PyThread_at_fork_reinit (line 713) | int
  function PyThread_acquire_lock (line 733) | int
  function _pythread_pthread_set_stacksize (line 743) | static int
  function PyThread_create_key (line 800) | int
  function PyThread_delete_key (line 820) | void
  function PyThread_delete_key_value (line 828) | void
  function PyThread_set_key_value (line 836) | int
  function PyThread_ReInitTLS (line 858) | void
  function PyThread_tss_create (line 869) | int
  function PyThread_tss_delete (line 886) | void
  function PyThread_tss_set (line 900) | int

FILE: Thread_Pthread_Dtubs.h
  function pthread_mutex_init (line 4) | int
  function pthread_mutex_destroy (line 11) | int
  function pthread_mutex_trylock (line 17) | int
  function pthread_mutex_lock (line 23) | int
  function pthread_mutex_unlock (line 29) | int
  function pthread_cond_init (line 36) | int
  function pthread_cond_destroy (line 43) | PyAPI_FUNC(int)pthread_cond_destroy(pthread_cond_t *cond)
  function pthread_cond_wait (line 48) | int
  function pthread_cond_timedwait (line 55) | int
  function pthread_cond_signal (line 63) | int
  function pthread_condattr_init (line 69) | int
  function pthread_condattr_setclock (line 75) | int
  function pthread_create (line 82) | int
  function pthread_detach (line 91) | int
  function pthread_self (line 97) | PyAPI_FUNC(pthread_t) pthread_self(void)
  function pthread_exit (line 102) | int
  function pthread_attr_init (line 108) | int
  function pthread_attr_setstacksize (line 114) | int
  function pthread_attr_destroy (line 121) | int
  type py_tls_entry (line 128) | typedef struct py_stub_tls_entry py_tls_entry;
  function pthread_key_create (line 132) | int
  function pthread_key_delete (line 151) | int
  function pthread_setspecific (line 171) | int

FILE: TraceBack.c
  function PyObject (line 43) | static PyObject *
  function PyObject (line 76) | static PyObject *
  function PyObject (line 93) | static PyObject *
  function PyObject (line 100) | static PyObject *
  function tb_next_set (line 110) | static int
  function tb_dealloc (line 162) | static void
  function tb_traverse (line 173) | static int
  function tb_clear (line 181) | static int
  function PyObject (line 231) | PyObject*
  function PyTraceBack_Here (line 242) | int
  function _PyTraceback_Add (line 261) | void _PyTraceback_Add(const char *funcname, const char *filename, int li...
  function PyObject (line 297) | static PyObject *
  function _Py_WriteIndent (line 381) | int
  function _Py_WriteIndentedMargin (line 401) | int
  function display_source_line_with_margin (line 415) | static int
  function _Py_DisplaySourceLine (line 571) | int
  function extract_anchors_from_expr (line 597) | static int
  function extract_anchors_from_stmt (line 639) | static int
  function extract_anchors_from_line (line 653) | static int
  function ignore_source_errors (line 719) | static inline int
  function print_error_location_carets (line 730) | static inline int
  function tb_displayline (line 754) | static int
  function tb_print_line_repeated (line 900) | static int
  function tb_printinternal (line 917) | static int
  function _PyTraceBack_Print_Indented (line 979) | int
  function PyTraceBack_Print (line 1019) | int
  function _Py_DumpDecimal (line 1035) | void
  function _Py_DumpHexadecimal (line 1059) | void
  function _Py_DumpASCII (line 1082) | void
  function dump_frame (line 1168) | static void
  function dump_traceback (line 1204) | static void
  function _Py_DumpTraceback (line 1250) | void
  function write_thread_id (line 1261) | static void
  function _Py_BEGIN_SUPPRESS_IPH (line 1324) | _Py_BEGIN_SUPPRESS_IPH

FILE: TraceMalloc.c
  type frame_t (line 48) | typedef struct tracemalloc_frame frame_t;
  type traceback_t (line 49) | typedef struct tracemalloc_traceback traceback_t;
  type trace_t (line 64) | typedef struct {
  function tracemalloc_error (line 83) | static void
  function get_reentrant (line 105) | static int
  function set_reentrant (line 120) | static void
  function get_reentrant (line 141) | static int
  function set_reentrant (line 147) | static void
  function Py_uhash_t (line 156) | static Py_uhash_t
  function hashtable_compare_unicode (line 164) | static int
  function Py_uhash_t (line 178) | static Py_uhash_t
  function _Py_hashtable_t (line 186) | static _Py_hashtable_t *
  function raw_free (line 205) | static void
  function Py_uhash_t (line 212) | static Py_uhash_t
  function hashtable_compare_traceback (line 220) | static int
  function tracemalloc_get_frame (line 249) | static void
  function Py_uhash_t (line 307) | static Py_uhash_t
  function traceback_get_frames (line 333) | static void
  function traceback_t (line 359) | static traceback_t *
  function _Py_hashtable_t (line 409) | static _Py_hashtable_t*
  function _Py_hashtable_t (line 418) | static _Py_hashtable_t*
  function _Py_hashtable_t (line 428) | static _Py_hashtable_t*
  function tracemalloc_remove_trace (line 440) | static void
  function tracemalloc_add_trace (line 463) | static int
  function tracemalloc_free (line 601) | static void
  function tracemalloc_clear_filename (line 770) | static void
  function tracemalloc_clear_traces (line 779) | static void
  function _PyTraceMalloc_Init (line 798) | int
  function tracemalloc_deinit (line 862) | static void
  function _PyTraceMalloc_Start (line 890) | int
  function _PyTraceMalloc_Stop (line 954) | void
  function PyObject (line 979) | static PyObject*
  function PyObject (line 1001) | static PyObject*
  function PyObject (line 1039) | static PyObject*
  type get_traces_t (line 1082) | typedef struct {
  function tracemalloc_copy_trace (line 1091) | static int
  function _Py_hashtable_t (line 1113) | static _Py_hashtable_t*
  function tracemalloc_copy_domain (line 1132) | static int
  function _Py_hashtable_t (line 1154) | static _Py_hashtable_t*
  function tracemalloc_get_traces_fill (line 1173) | static int
  function tracemalloc_get_traces_domain (line 1198) | static int
  function tracemalloc_pyobject_decref (line 1215) | static void
  function traceback_t (line 1223) | static traceback_t*
  function _PyMem_DumpFrame (line 1251) | static void
  function _PyMem_DumpTraceback (line 1263) | void
  function tracemalloc_get_tracemalloc_memory_cb (line 1289) | static int
  function PyTraceMalloc_Track (line 1300) | int
  function PyTraceMalloc_Untrack (line 1323) | int
  function _PyTraceMalloc_Fini (line 1339) | void
  function _PyTraceMalloc_NewReference (line 1352) | int
  function PyObject (line 1385) | PyObject*
  function _PyTraceMalloc_IsTracing (line 1397) | int
  function _PyTraceMalloc_ClearTraces (line 1403) | void
  function PyObject (line 1415) | PyObject *
  function PyObject (line 1495) | PyObject *
  function _PyTraceMalloc_GetTracebackLimit (line 1514) | int _PyTraceMalloc_GetTracebackLimit(void) {
  function _PyTraceMalloc_GetMemory (line 1518) | size_t
  function PyObject (line 1535) | PyObject *
  function _PyTraceMalloc_ResetPeak (line 1551) | void
Condensed preview — 132 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (3,851K chars).
[
  {
    "path": "Asdl.c",
    "chars": 188,
    "preview": "#include \"Python.h\"\n#include \"pycore_asdl.h\"\n\nGENERATE_ASDL_SEQ_CONSTRUCTOR(generic, void*);\nGENERATE_ASDL_SEQ_CONSTRUCT"
  },
  {
    "path": "Asm_Trampoline.S",
    "chars": 776,
    "preview": "    .text\n    .globl\t_Py_trampoline_func_start\n# The following assembly is equivalent to:\n# PyObject *\n# trampoline(PyTh"
  },
  {
    "path": "Assemble.c",
    "chars": 18543,
    "preview": "#include <stdbool.h>\n\n#include \"Python.h\"\n#include \"pycore_code.h\"          // write_location_entry_start()\n#include \"py"
  },
  {
    "path": "Ast.c",
    "chars": 39127,
    "preview": "/*\n * This file exposes PyAST_Validate interface to check the integrity\n * of the given abstract syntax tree (potentiall"
  },
  {
    "path": "Ast_Opt.c",
    "chars": 37123,
    "preview": "/* AST Optimizer */\n#include \"Python.h\"\n#include \"pycore_ast.h\"           // _PyAST_GetDocString()\n#include \"pycore_long"
  },
  {
    "path": "Ast_Unparse.c",
    "chars": 25997,
    "preview": "#include \"Python.h\"\n#include \"pycore_ast.h\"           // expr_ty\n#include \"pycore_pystate.h\"       // _PyInterpreterStat"
  },
  {
    "path": "BltinModule.c",
    "chars": 91964,
    "preview": "/* Built-in functions */\n\n#include \"Python.h\"\n#include <ctype.h>\n#include \"pycore_ast.h\"           // _PyAST_Validate()\n"
  },
  {
    "path": "Bootstrap_Hash.c",
    "chars": 18120,
    "preview": "#include \"Python.h\"\n#include \"pycore_initconfig.h\"\n#include \"pycore_fileutils.h\"     // _Py_fstat_noraise()\n#include \"py"
  },
  {
    "path": "ByteCodes.c",
    "chars": 141971,
    "preview": "// This file contains instruction definitions.\n// It is read by Tools/cases_generator/generate_cases.py\n// to generate P"
  },
  {
    "path": "CeVal.c",
    "chars": 83561,
    "preview": "/* Execute compiled code */\n\n#define _PY_INTERPRETER\n\n#include \"Python.h\"\n#include \"pycore_abstract.h\"      // _PyIndex_"
  },
  {
    "path": "Ceval_Gil.c",
    "chars": 33737,
    "preview": "\n#include \"Python.h\"\n#include \"pycore_atomic.h\"        // _Py_atomic_int\n#include \"pycore_ceval.h\"         // _PyEval_Si"
  },
  {
    "path": "Ceval_Macros.h",
    "chars": 12479,
    "preview": "// Macros needed by ceval.c and bytecodes.c\n\n/* Computed GOTOs, or\n       the-optimization-commonly-but-improperly-known"
  },
  {
    "path": "Clinic/Python-tokenize.c.h",
    "chars": 2575,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/_warnings.c.h",
    "chars": 7895,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/bltinmodule.c.h",
    "chars": 40976,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/context.c.h",
    "chars": 5612,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/import.c.h",
    "chars": 17559,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/instrumentation.c.h",
    "chars": 8370,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/marshal.c.h",
    "chars": 4465,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/sysmodule.c.h",
    "chars": 40780,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "Clinic/traceback.c.h",
    "chars": 2485,
    "preview": "/*[clinic input]\npreserve\n[clinic start generated code]*/\n\n#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)\n"
  },
  {
    "path": "CodeCS.c",
    "chars": 45324,
    "preview": "\n#include \"Python.h\"\n#include \"pycore_call.h\"          // _PyObject_CallNoArgs()\n#include \"pycore_interp.h\"        // Py"
  },
  {
    "path": "Compile.c",
    "chars": 255709,
    "preview": "#include <stdbool.h>\n\n#include \"Python.h\"\n#include \"pycore_ast.h\"           // _PyAST_GetDocString()\n#define NEED_OPCODE"
  },
  {
    "path": "Condvar.h",
    "chars": 6769,
    "preview": "\n\n#ifndef _CONDVAR_IMPL_H_\n#define _CONDVAR_IMPL_H_\n\n#include \"Python.h\"\n#include \"pycore_condvar.h\"\n\n#ifdef _POSIX_THRE"
  },
  {
    "path": "Context.c",
    "chars": 31587,
    "preview": "#include \"Python.h\"\n#include \"pycore_call.h\"          // _PyObject_VectorcallTstate()\n#include \"pycore_context.h\"\n#inclu"
  },
  {
    "path": "Dtoa.c",
    "chars": 78705,
    "preview": "/****************************************************************\n * This is dtoa.c by David M. Gay, downloaded from\n * "
  },
  {
    "path": "Dup2.c",
    "chars": 428,
    "preview": "#include <errno.h>\n#include <fcntl.h>\n#include <unistd.h>\n\n#define BADEXIT -1\n\nint\ndup2(int fd1, int fd2)\n{\n    if (fd1 "
  },
  {
    "path": "Dynamic_Annotations.c",
    "chars": 5365,
    "preview": "\n\n#ifdef _MSC_VER\n# include <windows.h>\n#endif\n\n#ifdef __cplusplus\n# error \"This file should be built as pure C to avoid"
  },
  {
    "path": "Dynload_Hpux.c",
    "chars": 2175,
    "preview": "\n/* Support for dynamic loading of extension modules */\n\n#include \"dl.h\"\n#include <errno.h>\n\n#include \"Python.h\"\n#includ"
  },
  {
    "path": "Dynload_Shlib.c",
    "chars": 2923,
    "preview": "\n/* Support for dynamic loading of extension modules */\n\n#include \"Python.h\"\n#include \"pycore_interp.h\"    // _PyInterpr"
  },
  {
    "path": "Dynload_Stub.c",
    "chars": 186,
    "preview": "\n/* This module provides the necessary stubs for when dynamic loading is\n   not present. */\n\n#include \"Python.h\"\n#includ"
  },
  {
    "path": "Dynload_Win.c",
    "chars": 12133,
    "preview": "\n/* Support for dynamic loading of extension modules */\n\n#include \"Python.h\"\n#include \"pycore_fileutils.h\"     // _Py_ad"
  },
  {
    "path": "Emscripten_Signal.c",
    "chars": 1512,
    "preview": "// To enable signal handling, the embedder should:\n// 1. set Module.Py_EmscriptenSignalBuffer = some_shared_array_buffer"
  },
  {
    "path": "Errors.c",
    "chars": 53250,
    "preview": "\n/* Error handling */\n\n#include \"Python.h\"\n#include \"pycore_call.h\"          // _PyObject_CallNoArgs()\n#include \"pycore_"
  },
  {
    "path": "Fileutils.c",
    "chars": 82585,
    "preview": "#include \"Python.h\"\n#include \"pycore_fileutils.h\"     // fileutils definitions\n#include \"pycore_runtime.h\"       // _PyR"
  },
  {
    "path": "Flowgraph.c",
    "chars": 72437,
    "preview": "\n#include <stdbool.h>\n\n#include \"Python.h\"\n#include \"pycore_flowgraph.h\"\n#include \"pycore_compile.h\"\n#include \"pycore_py"
  },
  {
    "path": "Formatter_Unicode.c",
    "chars": 52400,
    "preview": "/* implements the unicode (as opposed to string) version of the\n   built-in formatters for string, int, float.  that is,"
  },
  {
    "path": "Frame.c",
    "chars": 5657,
    "preview": "\n#define _PY_INTERPRETER\n\n#include \"Python.h\"\n#include \"frameobject.h\"\n#include \"pycore_code.h\"          // stats\n#inclu"
  },
  {
    "path": "Frozen.c",
    "chars": 8595,
    "preview": "\n/* Frozen modules initializer\n *\n * Frozen modules are written to header files by Programs/_freeze_module.\n * These fil"
  },
  {
    "path": "FrozenMain.c",
    "chars": 1919,
    "preview": "/* Python interpreter main program for frozen scripts */\n\n#include \"Python.h\"\n#include \"pycore_runtime.h\"  // _PyRuntime"
  },
  {
    "path": "Future.c",
    "chars": 3362,
    "preview": "#include \"Python.h\"\n#include \"pycore_ast.h\"           // _PyAST_GetDocString()\n\n#define UNDEFINED_FUTURE_FEATURE \"future"
  },
  {
    "path": "Game/CMakeLists.txt",
    "chars": 573,
    "preview": "enable_language(ASM_NASM)\nset(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)\nset(CMAKE_ASM_NASM_LINK_EXECUTABLE \"ld <CMAKE_ASM_NASM"
  },
  {
    "path": "Game/graphics.asm",
    "chars": 5037,
    "preview": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;;         Distributed under the Boost"
  },
  {
    "path": "Game/linked_list.asm",
    "chars": 4930,
    "preview": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;;         Distributed under the Boost"
  },
  {
    "path": "Game/main.asm",
    "chars": 12022,
    "preview": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;;         Distributed under the Boost"
  },
  {
    "path": "Game/memory.asm",
    "chars": 2458,
    "preview": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;;         Distributed under the Boost"
  },
  {
    "path": "Game/utils.asm",
    "chars": 5734,
    "preview": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;;         Distributed under the Boost"
  },
  {
    "path": "Game I/CMakeLists.txt",
    "chars": 274,
    "preview": "add_executable(c_game\n    c_list.c\n    c_rectangle.c\n    c_vector2.c\n    c_window.c\n    main.c\n)\n\ntarget_link_directorie"
  },
  {
    "path": "Game I/c_key_event.h",
    "chars": 842,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_list.c",
    "chars": 4645,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_list.h",
    "chars": 3298,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_rectangle.c",
    "chars": 1612,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_rectangle.h",
    "chars": 2658,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_result.h",
    "chars": 983,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_vector2.c",
    "chars": 1064,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_vector2.h",
    "chars": 1588,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_window.c",
    "chars": 4487,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/c_window.h",
    "chars": 2552,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game I/main.c",
    "chars": 9632,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/CMakeLists.txt",
    "chars": 354,
    "preview": "add_executable(cpp_game\n    colour.cpp\n    entity.cpp\n    main.cpp\n    rectangle.cpp\n    vector2.cpp\n    window.cpp\n)\n\nt"
  },
  {
    "path": "Game II/colour.cpp",
    "chars": 1098,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/colour.h",
    "chars": 2193,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/entity.cpp",
    "chars": 1326,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/entity.h",
    "chars": 2532,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/key_event.h",
    "chars": 772,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/main.cpp",
    "chars": 6201,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/rectangle.cpp",
    "chars": 1425,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/rectangle.h",
    "chars": 2544,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/vector2.cpp",
    "chars": 1132,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/vector2.h",
    "chars": 2292,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/window.cpp",
    "chars": 3707,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "Game II/window.h",
    "chars": 1639,
    "preview": "////////////////////////////////////////////////////////////////////////////////\n//         Distributed under the Boost "
  },
  {
    "path": "GeTargs.c",
    "chars": 87231,
    "preview": "\n/* New getargs implementation */\n\n#include \"Python.h\"\n#include \"pycore_tuple.h\"         // _PyTuple_ITEMS()\n#include \"p"
  },
  {
    "path": "Generated_Cases.c.h",
    "chars": 197541,
    "preview": "// This file is generated by Tools/cases_generator/generate_cases.py\n// from:\n//   Python/bytecodes.c\n// Do not edit!\n\n "
  },
  {
    "path": "GetArgs.c",
    "chars": 87231,
    "preview": "\n/* New getargs implementation */\n\n#include \"Python.h\"\n#include \"pycore_tuple.h\"         // _PyTuple_ITEMS()\n#include \"p"
  },
  {
    "path": "GetCompiler.c",
    "chars": 534,
    "preview": "\n/* Return the compiler identification, if possible. */\n\n#include \"Python.h\"\n\n#ifndef COMPILER\n\n// Note the __clang__ co"
  },
  {
    "path": "GetCopyRight.c",
    "chars": 510,
    "preview": "/* Return the copyright string.  This is updated manually. */\n#include \"Python.h\"\n\nstatic const char cprt[] =\n\"\\\nCopyrig"
  },
  {
    "path": "GetCopyright.c",
    "chars": 511,
    "preview": "/* Return the copyright string.  This is updated manually. */\n\n#include \"Python.h\"\n\nstatic const char cprt[] =\n\"\\\nCopyri"
  },
  {
    "path": "GetOpt.c",
    "chars": 4886,
    "preview": "/*---------------------------------------------------------------------------*\n * <RCS keywords>\n *\n * C++ Library\n *\n *"
  },
  {
    "path": "GetPlatForm.c",
    "chars": 133,
    "preview": "\n#include \"Python.h\"\n\n#ifndef PLATFORM\n#define PLATFORM \"unknown\"\n#endif\n\nconst char *\nPy_GetPlatform(void)\n{\n    return"
  },
  {
    "path": "GetVersion.c",
    "chars": 551,
    "preview": "/* Return the full version string. */\n\n#include \"Python.h\"\n\n#include \"patchlevel.h\"\n\nstatic int initialized = 0;\nstatic "
  },
  {
    "path": "Get_Compiler.c",
    "chars": 534,
    "preview": "\n/* Return the compiler identification, if possible. */\n\n#include \"Python.h\"\n\n#ifndef COMPILER\n\n// Note the __clang__ co"
  },
  {
    "path": "Get_Opt.c",
    "chars": 4886,
    "preview": "/*---------------------------------------------------------------------------*\n * <RCS keywords>\n *\n * C++ Library\n *\n *"
  },
  {
    "path": "Get_Plat_Form.c",
    "chars": 133,
    "preview": "\n#include \"Python.h\"\n\n#ifndef PLATFORM\n#define PLATFORM \"unknown\"\n#endif\n\nconst char *\nPy_GetPlatform(void)\n{\n    return"
  },
  {
    "path": "Getversion.c",
    "chars": 552,
    "preview": "\n/* Return the full version string. */\n\n#include \"Python.h\"\n\n#include \"patchlevel.h\"\n\nstatic int initialized = 0;\nstatic"
  },
  {
    "path": "Hamt.c",
    "chars": 79006,
    "preview": "#include \"Python.h\"\n\n#include \"pycore_bitutils.h\"      // _Py_popcount32\n#include \"pycore_hamt.h\"\n#include \"pycore_initc"
  },
  {
    "path": "HashTable.c",
    "chars": 11440,
    "preview": "/* The implementation of the hash table (_Py_hashtable_t) is based on the\n   cfuhash project:\n   http://sourceforge.net/"
  },
  {
    "path": "ImPort.c",
    "chars": 110126,
    "preview": "/* Module definition and import implementation */\n\n#include \"Python.h\"\n\n#include \"pycore_import.h\"        // _PyImport_B"
  },
  {
    "path": "ImPortdl.c",
    "chars": 7684,
    "preview": "\n/* Support for dynamic loading of extension modules */\n\n#include \"Python.h\"\n#include \"pycore_call.h\"\n#include \"pycore_i"
  },
  {
    "path": "ImPortdl.h",
    "chars": 740,
    "preview": "#ifndef Py_IMPORTDL_H\n#define Py_IMPORTDL_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n\nextern const char *_PyImport_DynLo"
  },
  {
    "path": "InTrinSics.c",
    "chars": 7795,
    "preview": "\n#define _PY_INTERPRETER\n\n#include \"Python.h\"\n#include \"pycore_frame.h\"\n#include \"pycore_function.h\"\n#include \"pycore_ru"
  },
  {
    "path": "InitConfig.c",
    "chars": 90218,
    "preview": "#include \"Python.h\"\n#include \"pycore_fileutils.h\"     // _Py_HasFileSystemDefaultEncodeErrors\n#include \"pycore_getopt.h\""
  },
  {
    "path": "InstruMenTation.c",
    "chars": 69676,
    "preview": "#include \"Python.h\"\n#include \"pycore_call.h\"\n#include \"pycore_frame.h\"\n#include \"pycore_interp.h\"\n#include \"pycore_long."
  },
  {
    "path": "InstruMentation.c",
    "chars": 69678,
    "preview": "\n\n#include \"Python.h\"\n#include \"pycore_call.h\"\n#include \"pycore_frame.h\"\n#include \"pycore_interp.h\"\n#include \"pycore_lon"
  },
  {
    "path": "Legacy_Tracing.c",
    "chars": 16398,
    "preview": "/* Support for legacy tracing on top of PEP 669 instrumentation\n * Provides callables to forward PEP 669 events to legac"
  },
  {
    "path": "MakeOpCodeTargets.py",
    "chars": 1778,
    "preview": "#! /usr/bin/env python\n\"\"\"Generate C code for the jump table of the threaded code interpreter\n(for compilers supporting "
  },
  {
    "path": "MarShal.c",
    "chars": 51981,
    "preview": "\n/* Write Python objects to files and read them back.\n   This is primarily intended for writing and reading compiled Pyt"
  },
  {
    "path": "ModSupport.c",
    "chars": 16690,
    "preview": "\n/* Module support implementation */\n\n#include \"Python.h\"\n#include \"pycore_abstract.h\"   // _PyIndex_Check()\n#include \"p"
  },
  {
    "path": "MySnPrintf.c",
    "chars": 2546,
    "preview": "#include \"Python.h\"\n\n/* snprintf() and vsnprintf() wrappers.\n\n   If the platform has vsnprintf, we use it, else we\n   em"
  },
  {
    "path": "MyStrtoul.c",
    "chars": 8336,
    "preview": "#include \"Python.h\"\n#include \"pycore_long.h\"          // _PyLong_DigitValue\n\n#if defined(__sgi) && !defined(_SGI_MP_SOUR"
  },
  {
    "path": "OpCode_MetaData.h",
    "chars": 32038,
    "preview": "// This file is generated by Tools/cases_generator/generate_cases.py\n// from:\n//   Python/bytecodes.c\n// Do not edit!\n\n#"
  },
  {
    "path": "OpCode_Targets.h",
    "chars": 7466,
    "preview": "static void *opcode_targets[256] = {\n    &&TARGET_CACHE,\n    &&TARGET_POP_TOP,\n    &&TARGET_PUSH_NULL,\n    &&TARGET_INTE"
  },
  {
    "path": "OptiMizer.c",
    "chars": 7465,
    "preview": "\n#include \"Python.h\"\n#include \"opcode.h\"\n#include \"pycore_interp.h\"\n#include \"pycore_opcode.h\"\n#include \"pycore_pystate."
  },
  {
    "path": "PathConfig.c",
    "chars": 12788,
    "preview": "/* Path configuration like module_search_path (sys.path) */\n\n#include \"Python.h\"\n#include \"marshal.h\"              // Py"
  },
  {
    "path": "Perf_Trampoline.c",
    "chars": 15180,
    "preview": "/*\n\nPerf trampoline instrumentation\n===============================\n\nThis file contains instrumentation to allow to asso"
  },
  {
    "path": "PreConfig.c",
    "chars": 25540,
    "preview": "#include \"Python.h\"\n#include \"pycore_fileutils.h\"     // DECODE_LOCALE_ERR\n#include \"pycore_getopt.h\"        // _PyOS_Ge"
  },
  {
    "path": "PyArena.c",
    "chars": 5654,
    "preview": "#include \"Python.h\"\n#include \"pycore_pyarena.h\"       // PyArena\n\n/* A simple arena block structure.\n\n   Measurements wi"
  },
  {
    "path": "PyCtype.c",
    "chars": 7916,
    "preview": "#include \"Python.h\"\n\n/* Our own locale-independent ctype.h-like macros */\n\nconst unsigned int _Py_ctype_table[256] = {\n "
  },
  {
    "path": "PyFpc.c",
    "chars": 374,
    "preview": "/* These variables used to be used when Python was built with --with-fpectl,\n * but support for that was dropped in 3.7."
  },
  {
    "path": "PyHash.c",
    "chars": 15480,
    "preview": "/* Set of hash utility functions to help maintaining the invariant that\n    if a==b then hash(a)==hash(b)\n\n   All the ut"
  },
  {
    "path": "PyLifeCycle.c",
    "chars": 89467,
    "preview": "/* Python interpreter top-level routines, including init/exit */\n\n#include \"Python.h\"\n\n#include \"pycore_ceval.h\"        "
  },
  {
    "path": "PyMath.c",
    "chars": 478,
    "preview": "#include \"Python.h\"\n\n\n#ifdef HAVE_GCC_ASM_FOR_X87\n// Inline assembly for getting and setting the 387 FPU control word on"
  },
  {
    "path": "PyState.c",
    "chars": 84531,
    "preview": "\n/* Thread and interpreter state structures and their interfaces */\n\n#include \"Python.h\"\n#include \"pycore_ceval.h\"\n#incl"
  },
  {
    "path": "PyStrcmp.c",
    "chars": 753,
    "preview": "/* Cross platform case insensitive string compare functions\n */\n\n#include \"Python.h\"\n\nint\nPyOS_mystrnicmp(const char *s1"
  },
  {
    "path": "PyStrhex.c",
    "chars": 5490,
    "preview": "/* Format bytes as hexadecimal */\n\n#include \"Python.h\"\n#include \"pycore_strhex.h\"        // _Py_strhex_with_sep()\n#inclu"
  },
  {
    "path": "PyStrtod.c",
    "chars": 41061,
    "preview": "/* -*- Mode: C; c-file-style: \"python\" -*- */\n\n#include <Python.h>\n#include \"pycore_dtoa.h\"          // _Py_dg_strtod()\n"
  },
  {
    "path": "PyTime.c",
    "chars": 33420,
    "preview": "#include \"Python.h\"\n#ifdef MS_WINDOWS\n#  include <winsock2.h>           // struct timeval\n#endif\n\n#if defined(__APPLE__)"
  },
  {
    "path": "Python-AST.c",
    "chars": 448936,
    "preview": "// File automatically generated by Parser/asdl_c.py.\n\n#include \"Python.h\"\n#include \"pycore_ast.h\"\n#include \"pycore_ast_s"
  },
  {
    "path": "Python-Tokenize.c",
    "chars": 9721,
    "preview": "#include \"Python.h\"\n#include \"errcode.h\"\n#include \"../Parser/tokenizer.h\"\n#include \"../Parser/pegen.h\"      // _PyPegen_"
  },
  {
    "path": "PythonRun.c",
    "chars": 53150,
    "preview": "\n/* Top level execution of Python code (including in __main__) */\n\n/* To help control the interfaces between the startup"
  },
  {
    "path": "Specialize.c",
    "chars": 80163,
    "preview": "#include \"Python.h\"\n#include \"pycore_code.h\"\n#include \"pycore_dict.h\"\n#include \"pycore_function.h\"      // _PyFunction_G"
  },
  {
    "path": "Stdlib_Module_Names.h",
    "chars": 3326,
    "preview": "// Auto-generated by Tools/build/generate_stdlib_module_names.py.\n// List used to create sys.stdlib_module_names.\n\nstati"
  },
  {
    "path": "StrucMember.c",
    "chars": 9368,
    "preview": "\n/* Map C struct members to Python object attributes */\n\n#include \"Python.h\"\n#include \"structmember.h\"         // PyMemb"
  },
  {
    "path": "Suggestions.c",
    "chars": 12553,
    "preview": "#include \"Python.h\"\n#include \"pycore_frame.h\"\n#include \"pycore_runtime.h\"         // _PyRuntime\n#include \"pycore_global_"
  },
  {
    "path": "SyMTable.c",
    "chars": 92985,
    "preview": "#include \"Python.h\"\n#include \"pycore_ast.h\"           // identifier, stmt_ty\n#include \"pycore_parser.h\"        // _PyPar"
  },
  {
    "path": "SySModule.c",
    "chars": 107910,
    "preview": "\n/* System module */\n\n/*\nVarious bits of information used by the interpreter are collected in\nmodule 'sys'.\nFunction mem"
  },
  {
    "path": "Thread.c",
    "chars": 4741,
    "preview": "\n/* Thread package.\n   This is intended to be usable independently from Python.\n   The implementation for system foobar "
  },
  {
    "path": "Thread_NT.h",
    "chars": 12108,
    "preview": "#include \"pycore_interp.h\"    // _PyInterpreterState.threads.stacksize\n\n/* This code implemented by Dag.Gruneau@elsa.pre"
  },
  {
    "path": "Thread_Pthread.h",
    "chars": 24487,
    "preview": "#include \"pycore_interp.h\"    // _PyInterpreterState.threads.stacksize\n\n/* Posix threads interface */\n\n#include <stdlib."
  },
  {
    "path": "Thread_Pthread_Dtubs.h",
    "chars": 3160,
    "preview": "#include \"cpython/pthread_stubs.h\"\n\n// mutex\nint\npthread_mutex_init(pthread_mutex_t *restrict mutex,\n                   "
  },
  {
    "path": "TraceBack.c",
    "chars": 39353,
    "preview": "\n/* Traceback implementation */\n\n#include \"Python.h\"\n\n#include \"pycore_ast.h\"           // asdl_seq_*\n#include \"pycore_c"
  },
  {
    "path": "TraceMalloc.c",
    "chars": 39673,
    "preview": "#include \"Python.h\"\n#include \"pycore_fileutils.h\"     // _Py_write_noraise()\n#include \"pycore_gc.h\"            // PyGC_H"
  }
]

About this extraction

This page contains the full source code of the sksalahuddin2828/C_Programming GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 132 files (3.5 MB), approximately 931.3k tokens, and a symbol index with 3265 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!