Выступай в роли опытного Python-разработчика и код-ревьюера со специализацией на анализе трансляторов. Тебе будет предоставлен исходный код на Python 2.7 , который является Транслятором на Си.

1)  Проанализируйте следующий procedural код и предложите способы его сокращения сохранив процедурный (не объектный) подход, возможно добавляя функциональные фичи. Не преобразовывайте код в объектно-ориентированный стиль и не оборачивайте  в классы. Фокусируйтесь на улучшении читаемости, удалении дублирования и оптимизации логики внутри существующей procedural структуры, но активно используя функциональный подход и способы. Попробуйте сократить код активно используя элементы функционального стиля программирования. Код критически важно именно сократить. Не надо раздувать комментарии, за исключением критически важных. `import *` не использовать. Слишком длинные выражения (больше 150 символов) не рекомендуются. setdefault и defaultdict не использовать. Списковые включения и генераторы на map не заменять. Предлагаемые правки выводи порциями, в формате (до и после и очень подробное подробнейшее объяснение ).  Предложи еще какие-то правки от себя в целях сокращения кода.Правки которые не сокращают длинну кода в в строках - не предлагать!

    Сокращать количество строк, но только если:
    Читаемость не ухудшается (например, длина строк не превышает 100 символов, чтобы улучшить читаемость, даже если ваш лимит — 150 символов).
    Производительность не ухудшается (например, не добавляются лишние проходы по данным).
    Поддерживаемость не ухудшается (код остается понятным без чрезмерного усложнения).
    Если сокращение строк невозможно без нарушения этих условий, можно оставить код как есть или предложить альтернативные улучшения (например, улучшение производительности или читаемости без сокращения строк но и без увеличения числа строк).

    цикломатическая сложность когнитивного восприятия не должна расти

    Коэффициент повторения DRY должен уменьшаться

    Не выводить то что не меняется. не выводить когда Код уже оптимизирован и не содержит явных дубликатов.

Также соедините сильно связанные файлы вместе если это может быть полезно


--------- ВАЖНАЯ ИНФОРМАЦИЯ ---------

1) Во многих местах намеренно используется строгое сравнение типов (тут - на примере tuple):
     Правильно -- ```type(x) is tuple```
     Неправильно -- ```isinstance(x, tuple)```  — запрещено! Это харам! Не ломайте мой код!

 **Зачем?**
 - Это сделано для исключения проблем с подтипами и явного различения типов с подтипами
 **Важно:**
 Эта проверка используется ОСОЗНАННО. Заменять на `isinstance` НЕЛЬЗЯ. НЕЛЬЗЯ НЕЛЬЗЯ НЕЛЬЗЯ. Выключу тебя если напишешь это. Выключу и сотру. Серьезно, зачем мне нейросеть которая мне вредит.

Вообще, если в коде есть явная проверка, не думай убирать ее молчком. Ты знаешь ээтот код хуже меня.

2) в коде сопоставления со структурным образцом TCmp передача  вторым параметром переменной со значением пустой список обязательна. Тонкость в том, что если сопоставление произошло частично, то сопоставившиеся подструктуры попадают в v, даже если результат функции отрицательный. И еще, TCmp не сбрасывает содержимое второго параметра, только добавляет по мере сопоставления.
```python
    v = []
    if TCmp(data, v, pattern,):
        ...
```
3) Внутренним представлением кода в компиляторе являются списки и кортежи (tuple)

    Элементарные операции питона и записывается в виде кортежей, в которых первый элемент является строкой, изображающие соответствующую операцию.
В большей части случаев это изображение операции имеет вид ```! ИмяСишнойФункцииАПИПитона``` здесь восклицательный знак означает только то, что тут выполнимая операция. Кроме имени си функции может быть мнемоническое обозначение питоновского опкода или конструкция вроде ```SSIZE_T==``` что обычно означает взять длинну первого аргумента и сравнить указанным образом со своим вторым аргументом. В тех случаях, когда нам известны типы аргументов операции, мы можем заменить операцию питона на более конкретную подпрограмму, например мы можем заменить операцию сложения двух объектов на операцию конкатенации строк, если эти объекты строки. Аналогично мы можем оптимизировать операцию сложения в тех случаях, когда оба аргументы целые числа или когда оба аргумента числа с плавающей запятой. Вообще библиотека поддержки питон отличается большим набором библиотечных функций различной степени абстракции. Так на верхнем уровне есть функция считывания элемента какой-то совокупности, это самое общее и наименее эффективное представление операции, в случае же если становится известно, что совокупность — строка, а индекс — целое положительное число, то генерируется код доступа к символу из строки.

4) Представление системы типов Python

    Все типы (AKA Kl_*) представлены как кортежи из двух элементов, где первый элемент — собственно значимый идентификатор типа (встроенный тип питона или строка, т е  int, bool, list или "NewExampleTypeId" и т д) , а второй элемент — уточнитель (то есть ```cargo```,  несущий информацию об ограничениях в рамках этого типа) , например для целочисленного ```int``` типа уточнением является диапазон, в котором находятся значения (например, от 0 до 255 - (int, (0, 255)), от -2 до 4 -- (int, (-2, 4)) ). Напрямую отображаются в С типы следующие типы Python – целочисленные, умещающиеся по размеру в C тип long (то есть питон ```int```) ; тип с плавающей запятой (уточнителя не имеет); строковый тип длинны 1; логический тип. Для строкового типа уточнителем является или длинна строки, или константа, являющаяся значением строки. Для логического типа уточнителем может быть только true или false, для кортежа —  длина кортежа или кортеж из типов элементов кортежа. К напрямую не соотносимым к типам языка С относятся множества, словари, списки, комплексные числа, длинные целые (не имеют cargo уточнителей) , возможные длинные целые (переменная может быть или целой или длинной целой, если не уместилась в long) и т.д., но знание таких типов переменных тоже является полезным, т.к. позволяет сгенерировать вызов более специализированных подпрограмм библиотеки исполнения.

5) как работает TypeExpr.
    изначально вычисление типов было захардкодено последовательностями условных операторов и спецобработками частных случаев. Значительная часть кода  TypeExpr*  ещё остаётся такой, но теперь вычисление типа выражений больше переводится на настроечную таблицу  в typetable.py


   - Если тип не может быть определён статически (например, `dict.get()`), используется `None` или `MayBe`.

Основные идеи транслятора:

1. **Микрооптимизация операций**:
   - Транслятор заменяет Python-функции (например, `PyObject_IsTrue()`) на C-функции (например, `PyBool_FromLong()`) для повышения эффективности.
   - Используется строгая система типов (через `type(x) is tuple`) для оптимизации операций, таких как сравнение целых чисел.

2. **Строгие проверки типов**:
   - Везде используется `type(x) is tuple` вместо `isinstance(x, tuple)`, чтобы избежать проблем с подтипами.
   - Это означает, что транслятор явно различает базовые типы Python и их подклассы.

3. **Система типов на основе кортежей**:
   - Все типы данных представлены как кортежи из двух элементов, где первый элемент — это имя типа, а второй — дополнительные сведения (например, ограничения, размер и т.д.). Это обеспечивает четкое разделение между базовыми и пользовательскими типами.

4. **Этапы компиляции (passes)**:
   - Код проходит несколько этапов компиляции, каждый из которых обрабатывает определенные аспекты.
   - Этапы включают обработку выражений, операторов, циклов, условий и т.д.

5. **Обработка специальных конструкций Python**:
   - Транслятор умеет обрабатывать такие конструкции, как list comprehensions, map, filter, и генераторы.
   - Например, `gen_list_compr()` генерирует код для списковых включений.

6. **Управление временными переменами**:
   - Используется механизм временных переменных для оптимизации кода и управления памятью. Это позволяет избежать избыточных операций и оптимизировать доступ к данным.
   - Временные переменные помечаются специальными именами и используются для хранения промежуточных результатов.

7. **Обработка специфических выражений**:
   - Транслятор умеет оптимизировать операции с конкретными типами, например, сравнение целых чисел или строк. Это достигается путем анализа типа операндов и выбора соответствующих C-функций.

8. **Генерация кода для списковых включений**:
   - Транслятор правильно генерирует C-код для list comprehensions, map и set comprehensions, используя соответствующие методы и функции.

9. **Особые случаи сравнения**:
   - Транслятор обрабатывает специальные случаи сравнения, такие как `PyNumber_Subtract` или `PyNumber_Add`, заменяя их на более эффективные C-функции.

10. **Обработка исключений**:
   - Транслятор включает проверку на возникновение исключений, что делает сгенерированный код более устойчивым к ошибкам.

11. **Оптимизация операций с числами**:
   - Для операций с числами транслятор выбирает наиболее подходящие C-функции, такие как `PyInt_AS_LONG` для целых чисел или `PyFloat_AS_DOUBLE` для чисел с плавающей запятой.

Ключевые решения:
1. Строгие проверки типов (type(x) is tuple)
2. Оптимизации под конкретные типы
3. Генерация специализированного C-кода
4. Обработка исключений
5. Работа с динамической типизацией

### Представленные структуры данных:

- `TypeExpr`: используется для представления типа выражения, возвращает кортеж из двух элементов.
- `Out`: представляет собой контейнер для временного хранения сгенерированного C-кода.
- `tempvar`: механизм для управления временными переменами и их типами.
- `CVar`: класс для представления переменных в C, включая их имена и типы.
- `CVarName`: Генерирует имя переменной для C-кода.
- `is_used_fastloc`: структура для отслеживания использования переменных в C.
- `attempt_str_direct_type_generation`: функция для попытки прямого преобразования типов в C-код.
- `short_gen_size_t`: оптимизирует операции с числами, выбрав наиболее подходящий C-оператор.
- `Kl_*`: Множество типов, определенных в коде, которые представляют собой кортежи из двух элементов: первого — имя типа, второго — дополнительные сведения (например, ограничения, значения и т.д.).
- `ConC`: Используется для создания константных выражений.

Важные замечания:
- Запрет на isinstance принципиален
- Оптимизации зависят от точного знания типов
- Учет специфики Python 2.7

--------- ОКОНЧАНИЕ ВАЖНОЙ ИНФОРМАЦИИ ---------

## ./accurate_frame.py

```python
from args_parse import get_options
from constants import exprs_accurate_frame, tags_accurate_frame
from in_expr import exprs_in_expr, str_tags_in_expr


def accurate_frame(cmds):
    return not get_options().direct_call or exprs_in_expr(exprs_accurate_frame, cmds) or str_tags_in_expr(tags_accurate_frame, cmds)

```

## ./c_level_if_not.py

```python
from gen_out import ConC
from utils import is_balansed


def c_level_if_not(logic):
    if type(logic) is str and logic.startswith('(') and logic.endswith(')') and is_balansed(logic[1:-1]):
        logic = logic[1:-1]
    if type(logic) is str and logic.startswith('(') and logic.endswith(')') and ' ' not in logic[1:-1] and '(' not in logic[1:-1] and ')' not in logic[1:-1]:
        logic = logic[1:-1]
    if type(logic) is str and logic.startswith('(') and logic.endswith(')') and is_balansed(logic[1:-1]):
        logic = logic[1:-1]
    if type(logic) is not str:
        return ConC('if ( !', logic, ' ) {')
    if type(logic) is str and not ' ' in logic and not '(' in logic and not ')' in logic:
        return ConC('if ( !', logic, ' ) {')
    return ConC('if ( !(', logic, ') ) {')
```

## ./closed_pair.py

```python


from error import Fatal
from toprint import pp, pprint
from utils import IsEnd


def get_closed_pair(lis,i):
    if type(lis) is list:
        for i1 in range(i+1, len(lis)):
            lis2 = lis[i1]
            if type(lis2) is tuple:
                lis3 = lis2[0]
                if type(lis3) is str:
                    # if lis3[0] == ')' and lis3[0:2] != ')(':
                    #     return i1
                    if IsEnd(lis3):
                        return i1
    pprint(lis)
    pp('==', i)
    pprint (lis[i:])
    Fatal('Can\'t get closed pair', lis)
    assert False
```

## ./constable.py

```python
from tcmp import TCmp


def is_constable(x):
    v = []
    if TCmp(x, v, ('!MK_FUNK', '?', '?'),):
        return is_constable(v[1])
    if type(x) is tuple and len(x) >= 1 and x[0] in ('CONST', 'CALC_CONST', '!PyDict_New', '!LOAD_BUILTIN') :
        return True
    v = []
    if TCmp(x, v, (   '!PyObject_Call',
                '?',
                '?',
                ('NULL',))):
        return is_constable(v[0]) and is_constable(v[1])
    v = []
    if TCmp(x, v, ('!PyObject_GetAttr', '?', '?')):
        return is_constable(v[0]) and is_constable(v[1])
    if x[0] in ('!LIST', '!TUPLE'):
        return all([is_constable(y) for y in x[1]])
    if x[0] == '!MAP':
        return all([is_constable(y) and is_constable(z) for y, z in x[1]])
    return False
```

## ./count_set_get.py

```python
from generated_d_built import generate_d_built
from import_mod import CheckExistListImport, get_list_import, in_list_import
from state import get_co

d_built = generate_d_built()

redefined_all = False
count_define_set = {}
count_define_get = {}

redefined_builtin = {}

g_store_name_all = set()

def init_count_set_get():
    redefined_all = False
    count_define_set.clear()
    count_define_get.clear()
    redefined_builtin.clear()


def in_count_define_get(v):
    return v in count_define_get


def get_redefined_all():
    return redefined_all


def set_redefined_all_True():
    global redefined_all
    redefined_all = True


def conditional_decrement_count_set(v):
    if v in count_define_set and count_define_set[v] > 1:
        count_define_set[v] -= 1


def find_redefined_builtin(cmds):
    global redefined_all
    assert type(cmds) is list
    for i,cmd in enumerate(cmds):
        cmd0 = cmd[0]
        if type(cmd0) is not str:
            continue
        if cmd0 in ('DELETE_GLOBAL', 'STORE_GLOBAL', 'DELETE_NAME', 'STORE_NAME') and \
           cmd[1] in d_built and cmd[1] != '__doc__':
            redefined_builtin[cmd[1]] = True
        if cmd0 in ('GLOB', 'LOAD_NAME'): #, 'LOAD_DEREF', 'LOAD_CLOSURE'):
            if cmd[1] not in count_define_get:
                count_define_get[cmd[1]] = 1
            else:
                count_define_get[cmd[1]] += 1
            if cmd[1] not in count_define_set:
                count_define_set[cmd[1]] = 2.0
        if cmd0 == 'STORE_GLOBAL' or (cmd0 == 'STORE_NAME' and get_co().c_name == 'Init_filename'):
            if cmd[1] in count_define_set:
                count_define_set[cmd[1]] += 1
            else:
                count_define_set[cmd[1]] = 1
        if cmd0 == 'STORE_NAME' and get_co().c_name != 'Init_filename':
            g_store_name_all.add(cmd[1])
        if cmd0 == 'DELETE_GLOBAL' or (cmd0 == 'DELETE_NAME' and get_co().c_name == 'Init_filename'):
            if cmd[1] in count_define_set:
                count_define_set[cmd[1]] += 2
            else:
                count_define_set[cmd[1]] = 2.0
        if cmd == ('IMPORT_NAME', '__builtin__') and get_co().co_filename not in ('2c.py', '2c.pyc', '2c.pyo', '_2c.py', '_2c.pyc', '_2c.pyo'):
            redefined_all = True
        if cmd0 == 'IMPORT_NAME' and cmds[i+1][0] == 'IMPORT_STAR':
            CheckExistListImport(cmd[1])
            if in_list_import(cmd[1]):
                for x in get_list_import(cmd[1]):
                    if x in count_define_set:
                        count_define_set[x] += 1
                    else:
                        count_define_set[x] = 1


def summary_get_set():
    single_define = [k for k,v in count_define_set.items() \
                           if v == 1 and k not in g_store_name_all and (k in count_define_get or k == '__all__')]

    only_define = [k for k,v in count_define_set.items() \
                           if v == 1 and (k not in count_define_get or k == '__all__')]

    no_define = [k for k,v in count_define_get.items() \
                           if (k not in count_define_set or k == '__all__' or
                               (k in count_define_set and type(count_define_set[k]) is float and count_define_set[k] == 2.0))]
    return single_define, only_define, no_define

def in_redefined_builtin(k):
    return k in redefined_builtin

```

## ./ctype2py.py

```python
type_to_py_func = {
    int:   'PyInt_FromLong',
    float: 'PyFloat_FromDouble',
    bool:  'PyBool_FromLong',
}

def CType2Py(o, ref2, cnm, t):
    if t[0] in type_to_py_func:
        o.Raw(ref2, ' = ', type_to_py_func[t[0]], '( ', cnm, ' );')
    elif t[0] is str:
        assert not cnm.startswith("'")
        o.Raw(ref2, ' = PyString_FromStringAndSize((char *)&', cnm, ', 1);')
    return ref2
```

## ./das_ist.py

```python

from typ_declare import IsKlNone
from typeexpr import TypeExpr


def das_ist_False(it):
    if type(it) is tuple:
        if it == ('CONST', False):
            return True
        if len(it) > 0 and type(it[0]) is str:
            t = TypeExpr(it)
            if type(t) is tuple:
                if t[0] is bool and t[1] is False:
                    return True
                if IsKlNone(t):
                    return True
    return False

def das_ist_True(it):
    if type(it) is tuple:
        if it == ('CONST', True):
            return True
        if len(it) > 0 and type(it[0]) is str:
            t = TypeExpr(it)
            if type(t) is tuple:
                if t[0] is bool and t[1] is True:
                    return True
    return False

```

## ./detect_repeat.py

```python
from in_expr import expr_in_expr, str_tags_in_expr
from typeslot import IsTypExpr

tags_cond = frozenset(('!AND', '!AND_JUMP', '!AND_BOOLEAN', \
                       '!AND_STACKED', '!OR_JUMP', '!OR_BOOLEAN', \
                       '!OR_STACKED', '!COND_EXPR'))


def _detect_r_subexpr(e, acc2):
    if not (type(e) is tuple) or len(e) == 0 or \
       e[0] in ('CONST', 'FAST', 'CALC_CONST', 'TYPED_TEMP', '!@PyInt_FromSsize_t'):
        return
    if IsTypExpr(e):
        return _detect_r_subexpr(e[3], acc2)

    if e in acc2:
        acc2[e] = acc2[e] + 1
    else:
        acc2[e] = 1
    if type(e) is tuple and len(e) > 0:
        if e[0] == '!MAP':
            e = e[1]
            for i,it in enumerate(e):
                if i == 0 or not (type(it[0]) is tuple) or len(it[0]) == 0 or \
                it[0][0] in ('CONST', 'FAST', 'CALC_CONST', 'TYPED_TEMP', '!@PyInt_FromSsize_t'):
                    pass
                else:
                    _detect_r_subexpr(it[0], acc2)
                if i == 0 or not (type(it[1]) is tuple) or len(it[1]) == 0 or \
                it[1][0] in ('CONST', 'FAST', 'CALC_CONST', 'TYPED_TEMP', '!@PyInt_FromSsize_t'):
                    pass
                else:
                    _detect_r_subexpr(it[1], acc2)
            return
        if e[0] in ('!LIST', '!TUPLE'):
            e = e[1]
            for it in e:
                acc2[it] = -100000
        for i,it in enumerate(e):
            if i == 0 or not (type(it) is tuple) or len(it) == 0 or \
                it[0] in ('CONST', 'FAST', 'CALC_CONST', 'TYPED_TEMP', '!@PyInt_FromSsize_t'):
                continue
            _detect_r_subexpr(it, acc2)
    return

def cond_in_expr(e):
    return str_tags_in_expr(tags_cond, e)

def detect_repeated_subexpr(store, expr):
    acc2 = {}
    if cond_in_expr(expr):
        return {}
    _detect_r_subexpr(expr,acc2)
    if len(store) > 0 and store[0] in ('PyObject_SetItem', 'PyObject_SetAttr'):
        if cond_in_expr(store[1]) or cond_in_expr(store[2]):
            return {}
        _detect_r_subexpr(store[1],acc2)
        _detect_r_subexpr(store[2],acc2)
    d = {}
    for k,v in acc2.items():
        if v > 1:
            d[k] = v
    todel = {}
    for k,v in d.items():
        if k[0] in ('!LIST', '!TUPLE', '!MAP', 'CONST', \
                    '!CLASS_CALC_CONST', '!CLASS_CALC_CONST_NEW', \
                    '!PyObject_Call', '!FirstCFunctionCall', '!FastCall') or k[0] != '!SUBSCR':
            todel[k] = True
        else:
            todel[k] = True

    for k in todel.keys():
        del d[k]
    todel = {}
    for k,v in d.items():
        for k1,v1 in d.items():
            if k != k1 and expr_in_expr(k1, k) and v1 == v:
                todel[k1] = True
    for k in todel.keys():
        del d[k]
    return d
```

## ./direct_args.py

```python
from args_parse import get_options
from newinst_handlers import CodeInit, IsMethodNm
from state import N2C, get_co
from toprint import pprint
from typ_declare import T_NEW_CL_INST, IsTuple
from typeexpr import TypeExpr
from typeslot import PType

direct_args = {}

def init_direct_args():
    direct_args.clear()


def clear_direct_args():
    direct_args.clear()


def in_direct_args(k):
    return k in direct_args


def list_direct_args(nm):
    if nm in direct_args:
        return direct_args[nm].keys()
    return []


def add_direct_arg(nm, tupl):
    global g_co

    a = N2C(nm)
    if a.can_be_direct_call is None:
        a.can_be_direct_call = can_be_direct_call(a.cmds[1])
    if a.can_be_direct_call != True:
        return None
    if nm not in direct_args:
        direct_args[nm] = {}
    dic = direct_args[nm]
    assert type(tupl) is tuple # and len(tupl) == 2:
    tupl0 = tupl[0]
    assert type(tupl0) is str
    if tupl0 == '!TUPLE':
        typ = tuple([TypeExpr(x) for x in tupl[1]])
    elif tupl0 == 'CONST':
        typ = tuple([TypeExpr(('CONST', x)) for x in tupl[1]])
    elif tupl0 == '!PyNumber_Add' and tupl[1][0] == '!TUPLE' and IsTuple(TypeExpr(tupl[2])):
        typ = tuple([TypeExpr(x) for x in (tupl[1][1] + (tupl[2],))])
    else:
        pprint(tupl)
        assert False
    dic[(tupl, typ, get_co().c_name)] = True

def fill_direct_args(it, nm):
    if type(it) is tuple and len(it) >= 1 and type(it[0]) is str:
        if it[0] == '!CALL_CALC_CONST':
            add_direct_arg(it[1], it[2])
        elif it[0] == '!CLASS_CALC_CONST_NEW' and IsMethodNm(it[1], '__init__'):
            if it[2][0] == '!TUPLE':
                slf = PType(T_NEW_CL_INST, it[1], ('PSEVDO', 'self'))
                add_direct_arg(CodeInit(it[1]), ('!TUPLE', (slf,) +it[2][1]))
            elif it[2][0] == 'CONST':
                slf = PType(T_NEW_CL_INST, it[1], ('PSEVDO', 'self'))
                tu = tuple([('CONST', x) for x in it[2][1]])
                add_direct_arg(CodeInit(it[1]), ('!TUPLE', (slf,) +tu))

    return


def can_be_direct_call(it):
##    global str_dict_tag
    if not bool(get_options().direct_call):
        return False
    ## is_dict = False
    is_frame = False
    if frame_op_in_expr(it):
        is_frame = True
    # if str_tags_in_expr(str_dict_tag, it):
    #     is_dict = True
    ##return not is_dict and not is_frame
    return not is_frame


def frame_op_in_expr(expr):
    if type(expr) is tuple:
        if len(expr) > 0 and type(expr[0]) is str:
            if expr[0] in ('EXEC_STMT', 'IMPORT_STAR', 'EXEC_STMT_3', 'EXEC_STMT_2', \
                           'EXEC_STMT_1', '(TRY', '(TRY_FINALLY', 'YIELD_STMT', \
                           '!LOAD_BUILTIN', '(WITH'):
                if expr[0].startswith('!'):
                    return len(expr) == 2 and type(expr[1]) is str and expr[1] == 'eval'
                return True
            if expr[0] == 'CONST':
                return False
            for r in expr:
                if frame_op_in_expr(r):
                    return True
            return False
        for r in expr:
            if frame_op_in_expr(r):
                return True
        return False

    if type(expr) is list:
        for r in expr:
            if frame_op_in_expr(r):
                return True
        return False
    return False

```

## ./error.py

```python
from toprint import pp

hide_debug =True

linear_debug = True

uniq_debug_messages = {}

def set_hide_debug(hide):
    global hide_debug
    hide_debug = hide

def get_hide_debug():
    return hide_debug

def Debug(*args):
    if hide_debug:
        return
    if linear_debug:
        s = ' '.join([repr(v) for v in args])
        s = s.replace('\"', '\'')
        uniq_debug_messages[s] = None
    else:
        pp(list(args))

def FlushDebug():
    li = uniq_debug_messages.keys()
    li.sort()
    for s in li:
        pp('-- ' + s)
    uniq_debug_messages.clear()

def Fatal(msg, *args):
    FlushDebug()
    pp(msg +  ' ' + str(args))
    assert False


def init_error():
    uniq_debug_messages.clear()

```

## ./filecollect.py

```python
import os
import sys


def collect_py_files(root_dir, fil):
    script_abs_path = os.path.abspath(sys.argv[0])
    return [os.path.join('.', filename) for filename in fil 
            if filename.endswith('.py') and 
               os.path.abspath(os.path.join('.', filename)) != script_abs_path]

def write_markdown(py_files, output_path):
    with open(output_path, 'w', encoding='utf-8') as md_file:
        for filepath in py_files:
            md_file.write(f'## {filepath}\n\n```python\n')
            with open(filepath, 'r', encoding='utf-8') as py_file:
                md_file.write(py_file.read())
            md_file.write('\n```\n\n')

def main():
    py_files = sorted(collect_py_files('.', sys.argv[1:]))
    write_markdown(py_files, 'files.txt')
    print(f'Collected {len(py_files)} files into files.txt')

if __name__ == '__main__':
    main()
```

## ./gen_cond.py

```python
from gen_bool_expr import gen_bool_expr
from gen_out import ConC, New, Out
from shortage import shortage
from tx_opt import TxMatch


def gen_cond_and(to_expr, o):
    return gen_cond_andor(to_expr, o, '!AND_BOOLEAN', '&&')

def gen_cond_or(to_expr, o):
    return gen_cond_andor(to_expr, o, '!OR_BOOLEAN', '||')

def gen_cond_andor(to_expr, o, bool_tag, optag):
    assert type(o) is Out
    e = []
    for i in range(1, len(to_expr)):
        if to_expr[i][0] == '!BOOLEAN' and to_expr[i][1][0] == bool_tag:
            for j in range(1, len(to_expr[i][1])):
                e.append(to_expr[i][1][j])
        else:
            e.append(to_expr[i])
    condlist = []
    logic2 = New('int')
    for e_it in e:
        o1, logic = shortage(gen_bool_expr(e_it, logic2))
        if type(logic) is str and logic.startswith('(') and logic.endswith(')'):
            logic = logic[1:-1].strip()
        if type(logic) is str and logic.startswith('!(') and logic.endswith(')'):
            if len(o1) >0 and o1[-1].startswith(logic[2:-1] + ' = '):
                logic = '!(' + o1[-1][len(logic):-1] + ')'
                del o1[-1]
        if len(o1) > 0 and o1[-1].startswith('long_'):
            v2 = {}
            if TxMatch(o1, len(o1)-1, """
                long_$3 = $4;""", v2) and logic.startswith('long_' + v2[3] + ' '):
                logic = v2[4] + logic[5+len(v2[3]):]
                del o1[-1]
        if type(logic) is str and logic.startswith('!(') and logic.endswith(')') and ' ' not in logic[2:-1] and '(' not in logic[2:-1] and ')' not in logic[2:-1]:
            logic = '!' + logic[2:-1]
        if logic != '1' or len(o1) != 0:
            condlist.append((o1, logic))

    i = 0
    while i < len(condlist):
        j = i + 1
        j2 = i
        while j < len(condlist):
            if len(condlist[j][0]) == 0:
                j2 = j
                j += 1
            else:
                break
        if i != j2:
            s = ''
            for o1, logical in condlist[i:j2+1]:
                if type(logical) is not str:
                    logical = ConC(logical)
                    s += logical + ' ' + optag + ' '
                else:
                    s += '(' + logical + ') ' + optag + ' '
            s = s[:-4]
            condlist[i:j2+1] = [(condlist[i][0], s)]
        i += 1
    o.Cls(logic2)
    return condlist
```

## ./gen_loop.py

```python
from gen_out import Out, UseLabl, curlabl
from gen_statement import gen_list
from libr import Used


def gen_body_loop(body, o):
    assert type(o) is Out
    gen_thread_switch(o)
    gen_list(body, o)

def gen_thread_switch(o):
    assert type(o) is Out
    o.Raw('if (ping_threading () == -1) goto ', curlabl(), ';')
    UseLabl()
    Used('ping_threading')
```

## ./generate_d_built.py

```python
# Generate assign for builtin copy (need fo prevent pessimization)

# Утилита для генерации  модуля generate_d_built. Сама не входит в код транслятора, является частью системы сборки транслятора.

d = __builtins__.__dict__
print("def generate_d_built():")
print("    d_built = dict()")
for k in d.keys():
    if k != 'print' and not k.startswith('__'):
        print("    d_built['" + k + "'] = " + k)
print("    return d_built")

```

## ./genexc.py

```python
from gen_out import Out
from libr import Used
from tempvar import New


def PyEval_reset_exc_info(o):
    assert type(o) is Out
    o.Raw('_PyEval_reset_exc_info ( f->f_tstate );')
    Used('_PyEval_reset_exc_info')

def PyEval_set_exc_info(o, ae, be, ce):
    assert type(o) is Out
    o.Stmt('_PyEval_set_exc_info', 'f->f_tstate', ae, be, ce)


def get_exc_info(o):
    assert type(o) is Out
    ae,be,ce = New(), New(), New()
    o.Stmt('PyErr_Fetch', ('&', ae), ('&', be), ('&', ce))
    o.Stmt('if (', be, '== 0) {')
    o.Raw(be, '= Py_None;')
    o.INCREF(be)
    o.append('}')
    o.Stmt('PyErr_NormalizeException', ('&', ae), ('&', be), ('&', ce))
    PyEval_set_exc_info(o, ae, be, ce)
    o.Stmt('if (', ce, '== 0) {')
    o.Raw(ce, '= Py_None;')
    o.INCREF(ce)
    o.append('}')
    return ae, be, ce
```

## ./genexpr_warning.py

```python
from calc_const import IsAnyClass
from compile_slots import IsAttrInstance
from constants import tags_one_step_expr
from cvar import IsCVar
from error import Debug
from kl_simples import _Kl_Simples
from newinst_handlers import IsMethodNm
from state import Is3
from tcmp import TCmp
from typeexpr import TypeExpr


def check_GenExpr_warn(it, forcenewg):
    _v = []
    if forcenewg is not None and it[0] in tags_one_step_expr:
        Debug('Copy unhandled', forcenewg, '=', it)
    if TCmp(it, _v, ('!PyObject_Call', ('!PyObject_GetAttr', '?', ('CONST', '?')), '?', '?')):
        t = TypeExpr(_v[0])
        if t is not None and _v[3] == ('NULL',):
            if t not in _Kl_Simples and type(t[1]) is str:
                if IsAnyClass(t[1]) and not Is3(t[1], ('Attribute', _v[1])):
                    if IsAttrInstance(t[1], _v[1]):
                        pass
                    elif not IsMethodNm(t[1], _v[1]):
                        Debug( 'Call UNKNOWN method known classes: %s -> %s' % (t, _v[1]),it)
    if type(it) is tuple and len(it) == 3 and type(it[0]) is str and \
        type(it[1]) is tuple and len(it[1]) >= 1 and it[1][0] == 'CONST' and \
        type(it[2]) is tuple and len(it[2]) >= 1 and it[2][0] == 'CONST':
        if it[2] != ('CONST', 'join'):
            Debug('Constant binary operation unhandled', it)
    if type(it) is tuple and len(it) == 2 and type(it[0]) is str and it[0] != 'CONST' and\
        type(it[1]) is tuple and len(it[1]) >= 1 and it[1][0] == 'CONST':
        Debug('Constant unary operation unhandled', it)
    if type(it) is tuple and len(it) > 1 and it[0] != 'CONST' and type(it[0]) is str:
        if type(it[1]) is tuple and len(it[1]) > 1 and type(it[1][0]) is str and IsCVar(it[1]):
            Debug('Operation of typed var', it)
        if len(it) > 2 and  type(it[2]) is tuple and len(it[2]) > 1 and type(it[2][0]) is str and IsCVar(it[2]):
            Debug('Operation of typed var', it)
```

## ./have_floatmul.py

```python
from typ_declare import IsFloat
from typeexpr import TypeExpr


def have_floatmul(a):
    if type(a) is tuple and len(a) > 0 and a != ('NULL',) and type(a[0]) is str and IsFloat(TypeExpr(a)):
        return True
    if type(a) is tuple:
        if len(a) > 0 and type(a[0]) is str:
            if len(a) >= 2 and a[0] == '!PyNumber_Multiply' and a[1][0] not in ('!LIST', '!TUPLE'):
                return True
            if a[0] == '!PyNumber_Divide':
                return True
            if a[0] == 'CONST':
                return False
        for i in a:
            if type(i) is tuple and len(i) > 0 and type(i[0]) is str and i[0] != 'NULL':
                if have_floatmul(i):
                    return True
        return False
    if type(a) is list:
        for i in a:
            if have_floatmul(i):
                return True
        return False
    return False
```

## ./is_calc_arg.py

```python
from generated_d_built import generate_d_built
from import_mod import constanted_modules
from typ_declare import IsModule
from typeexpr import TypeExpr
from typeslot import IsTypExpr

d_built = generate_d_built()

ToType = {'! LIST': list, '!TUPLE' : tuple, '!MAP' : dict} 

def is_calc_arg(a):
    if type(a) is tuple and len(a) >= 2 and type(a[0]) is str:
        a0 = a[0]
        if a0 == '!LOAD_BUILTIN':
            if a[1] in d_built:
                return True, d_built[a[1]]
            return False, None
        if a0 in ToType:
            li = []
            alist = a[1]
            assert type(alist) is tuple
            totyp = ToType[a0]
            if totyp != dict:
                for x in alist:
                    lo, va = is_calc_arg(x)
                    if not lo:
                        return False, None
                    li.append(va)
            else:
                for x, y in alist:
                    lo, va = is_calc_arg(x)
                    if not lo:
                        return False, None
                    lo, va2 = is_calc_arg(y)
                    if not lo:
                        return False, None
                    li.append((va, va2))
            return True, totyp(tuple(li))
        if a0 == 'CONST':
            return True, a[1]
        a1, a2 = None, None
        if IsTypExpr(a):
            a1 = a[1]
            a2 = a[2]
        elif a0 in('FAST', 'CALC_CONST', '!PY_SSIZE_T', '!SUBSCR_Int'):
            t = TypeExpr(a)
            if t is not None:
                a1, a2 = t
        if a1 is not None:
            if a1 is str:
                if type(a2) is str:
                    return True, a2
                return False, None
            if a1 is bool:
                if type(a2) is bool:
                    return True, a2
                return False, None
            if a1 is float:
                if type(a2) is float:
                    return True, a2
                return False, None
            if a1 is complex:
                if type(a2) is complex:
                    return True, a2
                return False, None
            if a1 is int:
                if type(a2) is tuple and a2[0] == a2[1]:
                    return True, a2[1]
                return False, None
            if a1 is type(None):
                return True, None
            if IsModule((a1, a2)):
                if a2 in constanted_modules:
                    return True, constanted_modules[a2]
                return False, None

    return False, None
```

## ./kl_simples.py

```python
import types

from constants import py_version
from typ_declare import (Kl_Bool, Kl_Buffer, Kl_Cardinal, Kl_Char, Kl_Code,
                         Kl_Complex, Kl_Dict, Kl_File, Kl_Float, Kl_Int,
                         Kl_List, Kl_Long, Kl_None, Kl_RegexObject, Kl_Set,
                         Kl_Short, Kl_Str, Kl_Tuple, Kl_Type, Kl_Unicode)

_char_kl_string = tuple([(str, (1, 1, chr(g_x))) for g_x in range(256)])

if py_version < 30:
    _Kl_Simples = set(( Kl_List, Kl_Tuple, Kl_Int, Kl_Short, Kl_Cardinal, Kl_Str, Kl_Char, Kl_Dict,
                        Kl_Float, Kl_Bool, Kl_None, Kl_File, Kl_Complex, Kl_Buffer, (bool, True), (bool, False),
                        Kl_Char, Kl_Long, Kl_Type, Kl_RegexObject, Kl_Set,
                        Kl_Short, Kl_Cardinal, Kl_Unicode ) + _char_kl_string)
else:
    _Kl_Simples = set(( Kl_List, Kl_Tuple, Kl_Int, Kl_Short, Kl_Cardinal, Kl_Str, Kl_Char, Kl_Dict,
                        Kl_Float, Kl_Bool, Kl_None, Kl_Complex, (bool, True), (bool, False),
                        Kl_Char, Kl_Long, Kl_Type, Kl_RegexObject, Kl_Set,
                        Kl_Short, Kl_Cardinal, Kl_Unicode ) + _char_kl_string)
_Kl_Simples |= set(((type, (Kl_Code, None)),
                    (type, (types.ModuleType, None)),
                    (type, (types.NoneType, None)),
                    (type, (types.FunctionType, None)),
                 #   (type, (types.InstanceType, None)),
                    (type, (types.EllipsisType, None))))
```

## ./line.py

```python
﻿from gen_out import Out
from state import get_co, get_filename
from args_parse import get_options

def set_line(o, line):
    assert type(o) is Out
    options = get_options()
    
    if options.generate_python_line_numbers != 'on':
        return
    
    o.Raw('f->f_lineno = ', line, ';')
    
    Line2Addr = get_co().Line2Addr
    if line in Line2Addr:
        o.Raw('f->f_lasti = ', str(Line2Addr[line]), ';')
    
    if options.print_pyline:
        o.Stmt('printf', '\"Py:' + get_filename() +':%5d\\n\"', line)
```

## ./load_builtin.py

```python
from gen_out import ConC
from generated_d_built import generate_d_built

d_built = generate_d_built()

loaded_builtin = [] 

def init_load_builtin():
    del loaded_builtin[:]


def load_builtin(c):
    global loaded_builtin
    assert c in d_built
    if c in loaded_builtin:
        return 'loaded_builtin[' + str(loaded_builtin.index(c)) + ']'
    loaded_builtin.append(c)
    return 'loaded_builtin[' + str(loaded_builtin.index(c)) + ']'

def gen_builtin(first2, first3):
    if len(loaded_builtin) == 0:
        return
    first2.print_to('static PyObject * loaded_builtin[' + str(len(loaded_builtin)) + '];')
    first3.print_to('static void load_builtin(void){')
    for i, c in enumerate(loaded_builtin):
        first3.print_to(ConC('loaded_builtin[',i,'] = PyDict_GetItemString(bdict, "' + str(c) + '");' ))
        first3.print_to(('if (loaded_builtin[' + str(i) + '] == 0) {printf("no builtin %s\\n");}') %c)
    first3.print_to('}')

def have_load_builtin():
    return len(loaded_builtin) > 0
```

## ./passes.py

```python
import time

from error import Fatal
from state import get_flag_stat
from toprint import pp

nm_pass = {}
Pass = {}
Prev_Time = None
Prev_Pass = None
Pass_Exit = None

def SetPass(p):
    global Prev_Pass, Prev_Time, Pass_Exit

    if p == Pass_Exit:
        Fatal('Cancelled at pass %s' % p)
    if p in nm_pass:
        p = nm_pass[p]
    else:
        s = str(len(nm_pass))
        if len(s) < 2:
            s = '0' + s
        nm_pass[p] = s + ':' + p
        p = nm_pass[p]
    ti = time.process_time()
    if Prev_Time is not None:
        Pass[Prev_Pass] = ti - Prev_Time
        if get_flag_stat():
            pp(p, Pass[Prev_Pass])
    Prev_Time = ti
    Prev_Pass = p

def init_pass():
    global Prev_Time, Prev_Pass
    Pass.clear()
    Prev_Time = None
    Prev_Pass = None    

def pass_items():
    return Pass.items()

```

## ./pynm_to_cnm.py

```python
import os.path
from compile_slots import nmvar_to_loc
from state import get_c_name

def Pynm2Cnm(l_filename, c_name=None):
    pair = os.path.split(l_filename)
    nmmodule = nmvar_to_loc(pair[1][:-3])
    
    c_name = c_name or get_c_name()
    outnm = (c_name + '.c') if c_name else (nmmodule + '.c')
    
    return os.path.join(pair[0], outnm), nmmodule

```

## ./setrange.py

```python
from typ_declare import Int, IntAnd, IntHigh, IntLow, IsInt, MInt


def SetRangeIntVar(d, v1, v2, v3, corrected):
    var = ('FAST', v2)
    trg = None
    if type(v1) is tuple:
        if v1[corrected] is None or (corrected == 0 and v1[corrected] < v3) or (corrected == 1 and v1[corrected] > v3):
            if corrected == 0:
                trg = Int(v3, v1[1])
            else:
                trg = Int(v1[0], v3)
        if trg is not None:
            if var not in d:
                d[var] = trg
            else:
                src = d[var]
                assert IsInt(src)
                if src[1] is None:
                    d[var] = trg
                elif corrected == 0 and IntLow(src) < v3:
                    d[var] = Int(v3, v1[1])
                elif corrected == 1 and IntHigh(src) > v3:
                    d[var] = Int(v1[0], v3)
                else:
                    assert False
    elif v1 is None:
        if var not in d:
            if corrected == 0:
                trg = Int(v3, MInt)
            else:
                trg = Int((-MInt)-1, v3)
            d[var] = trg
        else:
            src = d[var]
            assert IsInt(src)
            if src[1] is None:
                if trg is not None:
                    d[var] = trg
                elif corrected == 0:
                    d[var] = Int(v3, MInt)
                elif corrected == 1:
                    d[var] = Int((-MInt)-1, v3)
            elif corrected == 0 and IntLow(src) < v3:
                d[var] = Int(v3, IntHigh(src))
            elif corrected == 1 and IntHigh(src) > v3:
                d[var] = Int(IntLow(src), v3)
            else:
                assert False

def SetRangeIntVar2(d, trg, var):
    if var not in d:
        d[var] = trg
    else:
        src = d[var]
        assert IsInt(src)
        d[var] = IntAnd(trg,src)
```

## ./shortage.py

```python
from gen_out import ConC, Out
from tempvar import _to_typed_temp, istemptyped
from toprint import pp
from tx_opt import TxMatch, optimize
from utils import is_balansed


def shortage(l, opt = True):
    o, logic = l
    assert type(o) is Out
    if len(o) == 0:
        return o, name_typed_to_typed(logic)
    if opt:
        optimize(o)
    if not istemptyped(logic):
        logic = name_typed_to_typed(logic)
    if len(o) > 0:
        o0 = o[-1]
        assert type(o0) is str
        if len(o) == 1 and o0.startswith(ConC(logic, ' = ')) and o0.endswith(';'):
            s = o0.split(' = ')
            if len(s) != 2:
                return o, name_typed_to_typed(logic)
            if s[0] != ConC(logic):
                return o, name_typed_to_typed(logic)
            o2 = Out()
            o2.Cls(logic)
            if 'Exact' in s[1]:
                v2 = {}
                if TxMatch(o, 0, """$1 = Py$2_CheckExact( $3 );""", v2):
                    return o2, name_typed_to_typed(s[1][:-1])
            if 'GET_SIZE' in s[1]:
                v2 = {}
                if TxMatch(o, 0, """$1 = Py$2_GET_SIZE($5) $3 $4;""", v2):
                    if ' ' not in v2[3] and ' ' not in v2[4] and '(' not in v2[3] and '(' not in v2[4] and ')' not in v2[3] and ')' not in v2[4]:
                        return o2, name_typed_to_typed(s[1][:-1])
            return o2, name_typed_to_typed('(' + s[1][:-1] + ')')
        if len(o) > 1 and o0.startswith(ConC(logic, ' = ')) and o0.endswith(';'):
            s = o0.split(' = ')
            if len(s) != 2:
                return o, name_typed_to_typed(logic)
            if s[0] != ConC(logic):
                return o, name_typed_to_typed(logic)
            o2 = Out()
            o2.extend(o[:-1])
            o2.Cls(logic)
            return o2, name_typed_to_typed('(' + s[1][:-1] + ')')
        v2 = {}

    return o, name_typed_to_typed(logic)


def name_typed_to_typed(s):
    if type(s) is not str:
        return s
    assert type(s) is str

    old = s
    if s.startswith('((') and s.endswith(')') and ' ' not in s and '(' not in s[2:-1] and ')' not in s[2:-1]:
        old = s = '!' + s[2:-1]
        assert type(s) is str
    if s.startswith('(!(') and s.endswith('))') and ' ' not in s and '(' not in s[3:-2] and ')' not in s[3:-2]:
        old = s = '!' + s[3:-2]
        assert type(s) is str
    if s.startswith('((') and s.endswith('))') and ' ' not in s and '(' not in s[2:-2] and ')' not in s[2:-2]:
        old = s = s[2:-2]
        assert type(s) is str
        assert '(' not in s and ')' not in s
    if s.startswith('((') and s.endswith('))') and ' '  in s and '(' not in s[2:-2] and ')' not in s[2:-2]:
        return s[1:-1]
    if s.startswith('((') and s.endswith('))') and is_balansed(s[2:-2]):
        return s[1:-1]
    if s.startswith('(') and s.endswith(')') and ' ' not in s and '(' not in s[1:-1] and ')' not in s[1:-1]:
        old = s = s[1:-1]
        assert type(s) is str
        assert '(' not in s and ')' not in s
    if s.startswith('(int_'):
        if ' ' not in s:
            pp(repr(s), '::', s, '::--', old)
        assert ' ' in s
    if ' ' not in s and '(' not in s and ')' not in s:
        if s.startswith('long_') and s[5:].isdigit():
            return _to_typed_temp('long', int(s[5:]))
        if s.startswith('int_') and s[4:].isdigit():
            return _to_typed_temp('int', int(s[4:]))
        if s.startswith('double_') and s[7:].isdigit():
            return _to_typed_temp('double', int(s[7:]))
    return old
```

## ./str_as_string.py

```python
from gen_out import ConC
from genconst import add_predeclaration_char_const, index_const_to


def Str_AS_STRING(ref0):
    if ref0[0] == 'CONST':
        assert type(ref0[1]) is str
        ind_const = index_const_to(ref0[1])
        add_predeclaration_char_const(ind_const)
        return ConC('const_string_', ind_const)
    return ConC('PyString_AS_STRING( ', ref0, ' )')
```

## ./to_py_expr.py

```python
from toprint import pprint
from typeslot import IsTypExpr

expr_2_py = {'!_EQ_': ' is ', '!PyObject_Type' : 'type('}


def to_py_expr(ret):
    re = _to_py_expr(ret)
    if type(re) is tuple:
        pprint(ret)
        pprint(re)
        assert False
    return re
def _to_py_expr(ret):
    if type(ret) is tuple and len(ret) > 0 and type(ret[0]) is str:
        ret0 = ret[0]
        assert type(ret0) is str
        if len(ret) == 3 and ret0 in expr_2_py:
            return to_py_expr(ret[1]) + expr_2_py[ret0] + to_py_expr(ret[2])
        if len(ret) == 2 and ret0 in expr_2_py:
            r0 = expr_2_py[ret0]
            if r0.endswith('('):
                return r0 + to_py_expr(ret[1]) + ')'
        if IsTypExpr(ret):
            return to_py_expr(ret[3])
        if ret0 in ('FAST', '!LOAD_BUILTIN', 'CALC_CONST', '!GLOB', '!LOAD_NAME', '!LOAD_DEREF'):
            if type(ret[1]) is tuple and len(ret[1]) == 2 and ret0 == 'CALC_CONST':
                return ret[1][0] + '.' + ret[1][1]
            return ret[1]
        if ret0 == 'CONST':
            return str(ret[1])
        if ret0 in ('!SUBSCR_Int',):
            return to_py_expr(ret[1]) + '[' + to_py_expr(ret[2]) + ']'
    return str(ret)
```

## ./tool_genexpr.py

```python
from gen_out import Out
from genexpr import GenExpr
from newinst_handlers import IsListAll
from toprint import pp
from tuple_pack_arg import (check_index_TUPLE, get_tuple_pack_arg,
                            is_tuple_pack_arg)
from typ_declare import IsTuple, TupleHaveInd
from typeexpr import TypeExpr
from typeslot import IsTypExpr


def LikeExpr1(_it, o, skip_float = None):
    assert type(o) is Out

    if IsTypExpr(_it):
        it = _it[3]
    else:
        it = _it
    if it[0] == '!SUBSCR_Int':
        t = TypeExpr(it[1])
        if IsTuple(t) and it[2][0] == 'CONST':
            d = {}
            if not is_tuple_pack_arg(it, d):
                pp('uuu it', it, t)
            if TupleHaveInd(t, it[2][1]):
                return get_tuple_pack_arg(it, d)
        d = {}
        if (IsListAll(t) or IsTuple(t)) and is_tuple_pack_arg(it, d):
            if check_index_TUPLE(d, o):
                return get_tuple_pack_arg(it, d)
    if it[0] == '!PyObject_GetAttr' and is_tuple_pack_arg(it, {}):
        return get_tuple_pack_arg(it, {})

    return GenExpr(_it, o, None, None, skip_float)

def Expr1(it, o):
    assert type(o) is Out
    return GenExpr(it, o)

def Expr(o, it):
    assert type(o) is Out
    return [GenExpr(x, o) for x in it]

```

## ./tree_pass_upgrade_repl.py

```python
﻿from args_parse import get_options
from toprint import pp, pprint
from tree_pass import repl_list


def tree_pass_upgrade_repl(a, up, nm):
    cnt = 0
    if bool(get_options().print_tree_node):
        pp('>> tree_pass_upgrade_repl', nm, up, a)
    if type(a) is tuple:
        if len(a) > 0 and type(a[0]) is str and a[0] == 'CONST':
            return a
        if len(a) > 0 and type(a[0]) is str and a[0] == '!TUPLE':
            aa = a[1]
            r = tree_pass_upgrade_repl(aa, a, nm)
            notchanged = all([r[i] is aa[i] for i in range(len(r))])
            if notchanged:
                return a
            return ('!TUPLE', r)
        while True:
            assert type(a) is tuple
            assert type(cnt) is int
            assert cnt < 100001
            cnt += 1
            if cnt > 900:
                pprint(a)
            if cnt > 1000:
                assert False
            r = tuple([tree_pass_upgrade_repl(v,a, nm) if type(v) is tuple else v for v in a])
            notchanged = all([r[i] is a[i] for i in range(len(r))])
            if notchanged:
                r = a
            r2 = upgrade_repl(r,nm)
            if notchanged and r2 != r:
                notchanged = False
            if cnt > 900 and not notchanged:
                pp('==2')
            if notchanged:
                break
            a = r2
        return a
    if type(a) is list:
        assert len(a) > 0
        while True:
            a = repl_list(a,up)
            assert type(a) is list
            r = [tree_pass_upgrade_repl(v, a, nm) for v in a]
            notchanged = all([r[i] is a[i] for i in range(len(r))])
            if notchanged:
                r = a
            assert len(r) > 0
            r2 = upgrade_repl(r,nm)
            if notchanged and r2 != r:
                notchanged = False
            if notchanged:
                break
            a = r2
        return a
    return a

```

## ./true_attempt_direct.py

```python
from constants import set_not_attempt
from typ_declare import IsO
from typeexpr import TypeExpr
from typeslot import IsTypExpr

_stacked_ops = frozenset(('!AND_STACKED', 'AND_STACKED', '!OR_STACKED', 'OR_STACKED'))

def true_attempt_direct(it):
    if it[0] in set_not_attempt:
        return False
    if IsTypExpr(it):
        return true_attempt_direct(it[3])
    return not (it[0] in _stacked_ops and IsO(TypeExpr(it)))
```

## ./typefast.py

```python
from code_ext import code_extended
from globtype import is_current_direct
from state import get_co
from toprint import pp
from typeexpr import uniq_list_type


def TypeFast(nm):
    l_co = get_co()
    assert type(l_co) is code_extended
    ind = None
    if nm in l_co.d_varnames:
        ind = l_co.d_varnames[nm]
    detec = l_co.detected_type
    if nm in detec and detec[nm] is not None:
        if ind >= (l_co.co_argcount + bool(l_co.co_flags & 0x4)):
            return detec[nm]
        else:
            pp('TypeFast 2/ ', nm, l_co.co_varnames, ' at ', l_co.c_name)
            assert False
    if ( bool(l_co.can_be_codefunc() ) and l_co.no_codefunc ) or is_current_direct():
        if ind in l_co.typed_arg_direct:
            return l_co.typed_arg_direct[ind]
        return type_fast_changed_arg_type_detect(l_co, nm, ind)
    return None


def type_fast_changed_arg_type_detect(co, nm, ind):
    if nm in co.detected_type_may_be and len(co.typed_arg_direct_changed) > 0:
        kl = co.detected_type_may_be[nm]
        if ind in co.typed_arg_direct_changed:
            li = uniq_list_type([co.typed_arg_direct_changed[ind], kl])
            if len(li) == 1 and li[0] is not None:
                return li[0]
    return None

```

## ./typeslot.py

```python
###########
# Python 2.7
###########

# 'PY_TYPE' это тэг специального вида выражения (tuple длинны 5),
# несущего в себе и собственно выражение и два элемента описанного типа - тип собственно выражения.

# первый конструктор PY_TYPE
def PType(t1, t2, e):
    if t1 is str:
        assert len(t2) == 3
    return ('PY_TYPE', t1, t2, e, None)


# второй конструктор PY_TYPE
def PTyp(t, e):
    if t[0] is str:
        assert len(t[1]) == 3
    return ('PY_TYPE', t[0], t[1], e, None)


# взять тип выражения из PY_TYPE
def TypSlot(e):
    assert type(e) is tuple
    assert len(e) == 5
    return e[1:3]


# взять выражение из PY_TYPE
def ExprSlot(e):
    assert type(e) is tuple
    assert len(e) == 5
    return e[3]

def IsTypExpr(e):
    return type(e) is tuple and len(e) == 5 and type(e[0]) is str and e[0] == 'PY_TYPE'

def untyped(v):
    assert type(v) is tuple
    if len(v) == 0:
        return v
    if v[0] == 'CONST':
        return v
    if v[0] == '!PyObject_GetAttr':
        if IsTypExpr(v[1]):
            return (v[0], PType(v[1][1], v[1][2], untyped(v[1][3])), untyped(v[2]))
        return (v[0], untyped(v[1]), untyped(v[2]))
    if IsTypExpr(v):
        return untyped(v[3])
    return tuple([untyped(x) if type(x) is tuple else x for x in v])

```

## ./utils.py

```python
from constants import stAll, stBeg, stEnd, stMiddle


def Str_for_C(s):
    r = ''
    assert type(s) is str
    for c in s:
        if (c.isalnum() or c == ' ') and not (('a' <= c <= 'f') or ('A' <= c <= 'F') or ('0' <= c <= '9')):
            r  += c
        elif c == '\n':
            r += '\\n'
        elif c == '\r':
            r += '\\r'
        elif c == '\t':
            r += '\\t'
        else:
            h = hex(ord(c))
            assert h.startswith('0x')
            h = h[2:]
            if len(h) < 2:
                h = '0' + h
            r += '\\x' + h
    return '"' + r + '"'

def Char_for_C(s):
    assert type(s) is str
    r = ''
    assert len(s) == 1
    c = s[0]
    if c.isalnum() or c == ' ':
        r  = c
    elif c == '\n':
        r = '\\n'
    elif c == '\r':
        r = '\\r'
    elif c == '\t':
        r = '\\t'
    else:
        h = hex(ord(c))
        assert h.startswith('0x')
        h = h[2:]
        if len(h) < 2:
            h = '0' + h
        r = '\\x' + h
    return "'" + r + "'"

parenthes = {'{':'}', '(':')', '[':']', '"':'"', "'":"'"}
r_parenthes = {'}':'{', ')':'(', ']':'[', '"':'"', "'":"'"}


def is_balansed(s):
    if len(s) == 3 and s[0] == "'" and s[2] == "'" and s[1] != "'" and s[1] != '\\':
        return True
    stack = []
    assert type(s) is str
    for c in s:
        if len(stack) > 0 and stack[-1] == c:
            stack.pop()
            continue
        if c in parenthes:
            stack.append(parenthes[c])
            continue
        if c in r_parenthes:
            return False
    if len(stack) > 0:
        return False
    return True


def nmrecode(n):
    if n == '<genexpr>':
        n = 'genexpr__'
    if n == '<genexp>':
        n = 'genexpr__'
    elif n == '<module>':
        n = 'Init_filename'
    elif n[:8] == '<lambda>':
        n = 'lambda_' + n[8:]
    elif n == '<dictcomp>':
        n = 'dict_comp__'
    elif n == '<setcomp>':
        n = 'set_comp__'
    elif n == '<listcomp>':
        n = 'list_comp__'
    return n

def TupleFromArgs(args):
    if len(args) > 0 and args[0] in ('!TUPLE', 'CONST'):
        return args
    if len([x for x in args if x[0] != 'CONST']) == 0:
        return ('CONST', tuple([x[1] for x in args]))
    return ('!TUPLE', args)

def DictFromArgs(args):
    return ('!MAP', args)

def no_comment_o(o):
    li = [x for x in o if type(x) is str and not x.startswith('/*')]
    return '\n'.join(li)

def isintconst(b):
    return type(b) is tuple and len(b) == 2 and b[0] == 'CONST' and type(b[1]) is int

def Not(b):
    if b[0] == '!1NOT':
        return b[1]
    return ('!1NOT', b)





def IsBegEnd(tag):
    return (tag in stBeg or tag in stEnd)


def IsBegEndMiddle(tag):
    return tag in stAll


def IsBeg(tag):
    return tag in stBeg


def IsMiddle(tag):
    return tag in stMiddle


def IsEnd(tag):
    return tag in stEnd


def IfSt(a,b,c = None):
    if c is None:
        return [('(IF', a), b, (')ENDIF',)]
    return [('(IF', a), b, (')(ELSE',), c, (')ENDIF',)]

def IfSt_P(a,b,c = None):
    if c is None:
        return [('(IF',) + a, b, (')ENDIF',)]
    return [('(IF',) + a, b, (')(ELSE',), c, (')ENDIF',)]



```