// 2025-2026 Богданович Давид Когут Прихожденко (кдб.дійсність.укр)

взяти визначення мавка;
взяти визначення мавка/розбирач;

простір мавка {
  дія надрукувати_інформацію_падіння(
    М: *Машина,
    інформація_падіння: ІнформаціяПадіння
  ) {
    вивести_кольорово(М, КолірВиводуЧервоний, "Помилка");

    якщо інформація_падіння.місцезнаходження.шлях != пусто {
      вивести_кд(М, " в ");

      вивести_шлях(М, інформація_падіння.місцезнаходження.шлях.розмір, інформація_падіння.місцезнаходження.шлях.дані);

      якщо інформація_падіння.місцезнаходження.рядок > 0 {
        вивести_кд(М, ":");
        вивести_п64(М, п64(інформація_падіння.місцезнаходження.рядок));
      }

      вивести_кд(М, "\р");
    }

    надрукувати_значення(М, інформація_падіння.значення, 2, 0);

    змінна п: природне = 0;

    якщо інформація_падіння.розмір_історії > 0 {
      надрукувати_кд(М, "\рІсторія здійснення:");
    }

    поки п < інформація_падіння.розмір_історії {
      змінна елемент_історії = інформація_падіння.історія[п];

      змінна назва = "(безіменна)";

      якщо елемент_історії.назва != пусто {
        назва = елемент_історії.назва.значення;
      }

      вивести_кд(М, "  ");
      вивести_кольорово(М, КолірВиводуСиній, назва);

      якщо елемент_історії.місцезнаходження.шлях == пусто {
        вивести_кд(М, "\р");
      } інакше {
        вивести_кд(М, " в ");
        вивести_шлях(М, елемент_історії.місцезнаходження.шлях.розмір, елемент_історії.місцезнаходження.шлях.дані);

        якщо елемент_історії.місцезнаходження.рядок > 0 {
          вивести_кд(М, ":");
          вивести_п64(М, п64(елемент_історії.місцезнаходження.рядок));
        }

        вивести_кд(М, "\р");
      }

      п += 1;
    }
  }

  внутрішня дія вивести_пропуски(М: *Машина, кількість: природне) {
    змінна п: природне = 0;

    поки п < кількість {
      вивести_кд(М, " ");

      п += 1;
    }
  }

  внутрішня дія вивести_вбудований_предмет(
    М: *Машина,
    виведені_предмети: *Накопичувач<*Предмет>,
    предмет: *Предмет,
    розмір_відступу: природне,
    глибина: природне
  );
  внутрішня дія вивести_предмет(
    М: *Машина,
    виведені_предмети: *Накопичувач<*Предмет>,
    предмет: *Предмет,
    розмір_відступу: природне,
    глибина: природне
  );
  внутрішня дія вивести_значення_1(
    М: *Машина,
    виведені_предмети: *Накопичувач<*Предмет>,
    значення: Значення,
    розмір_відступу: природне,
    глибина: природне
  );

  внутрішня дія зберегти_стан_виведених_предметів(
    виведені_предмети: *Накопичувач<*Предмет>
  ) -> природне {
    вернути виведені_предмети.розмір;
  }

  внутрішня дія відновити_стан_виведених_предметів(
    виведені_предмети: *Накопичувач<*Предмет>,
    стан: природне
  ) {
    виведені_предмети.розмір = стан;
  }

  внутрішня дія покласти_виведений_предмет(
    М: *Машина,
    виведені_предмети: *Накопичувач<*Предмет>,
    предмет: *Предмет
  ) {
    виведені_предмети.покласти(М,
      предмет
    );
  }

  внутрішня дія предмет_вже_виведено(
    виведені_предмети: *Накопичувач<*Предмет>,
    предмет: *Предмет
  ) -> логічне {
    змінна п: природне = 0;

    поки п < виведені_предмети.розмір {
      якщо виведені_предмети.дані[п] == предмет {
        вернути так;
      }

      п += 1;
    }

    вернути ні;
  }

  внутрішня дія вивести_вбудований_предмет(
    М: *Машина,
    виведені_предмети: *Накопичувач<*Предмет>,
    предмет: *Предмет,
    розмір_відступу: природне,
    глибина: природне
  ) {
    якщо предмет.клас == М.клас_Клас {
      змінна властивості = предмет як *ПредметКласу;

      якщо властивості.назва == пусто {
        вивести_кольорово(М, КолірВиводуСиній, "<клас>");
      } інакше {
        вивести_кольорово(М, КолірВиводуСиній, "<клас ");

        вивести_кольорово(М, КолірВиводуСиній, властивості.назва.значення);

        вивести_кольорово(М, КолірВиводуСиній, ">");
      }

      вернути;
    }

    якщо предмет.клас == М.клас_Модуль {
      змінна властивості_модуля = предмет як *ПредметМодуля;

      якщо властивості_модуля.назва == пусто {
        вивести_кольорово(М, КолірВиводуСиній, "<модуль");
      } інакше {
        вивести_кольорово(М, КолірВиводуСиній, "<модуль ");

        вивести_кольорово(М, КолірВиводуСиній, властивості_модуля.назва.значення);
      }

      якщо властивості_модуля.властивості.вмісткість > 0 {
        вивести_кольорово(М, КолірВиводуСиній, "[");
        змінна п: природне = 0;
        змінна виведено_першу = ні;

        поки п < властивості_модуля.властивості.вмісткість {
          змінна призначене = властивості_модуля.властивості.дані[п];

          поки призначене != пусто {
            якщо виведено_першу {
              вивести_кольорово(М, КолірВиводуСиній, ", ");
            }

            виведено_першу = так;

            вивести_кольорово(М, КолірВиводуСиній, призначене.назва.значення);

            призначене = призначене.наступний;
          }

          п += 1;
        }
        вивести_кольорово(М, КолірВиводуСиній, "]");
      }

      вивести_кольорово(М, КолірВиводуСиній, ">");

      вернути;
    }

    якщо предмет.клас == М.клас_Текст {
      змінна властивості = предмет як *ПредметТексту;

      якщо глибина != 0 {
        вивести_кольорово(М, КолірВиводуЗелений, "\"");
      }

      якщо глибина == 0 {
        якщо глибина == 0 {
          вивести_кд(М, властивості.значення);
        } інакше {
          вивести_кольорово(М, КолірВиводуЗелений, властивості.значення);
        }
      } інакше {
        змінна п: природне = 0;
        поки п < властивості.значення.розмір {
          змінна символ = властивості.значення.дані[п];

          якщо символ == КД::символи::Міжряд {
            якщо глибина == 0 {
              вивести_кд(М, "\\р");
            } інакше {
                вивести_кольорово(М, КолірВиводуЗелений, "\\р");
            }
          } інакше якщо символ == КД::символи::Дволапка {
            якщо глибина == 0 {
              вивести_кд(М, "\\\"");
            } інакше {
                вивести_кольорово(М, КолірВиводуЗелений, "\\\"");
            }
          } інакше якщо символ == КД::символи::Обернена_похила {
            якщо глибина == 0 {
              вивести_кд(М, "\\\\");
            } інакше {
                вивести_кольорово(М, КолірВиводуЗелений, "\\\\");
            }
          } інакше якщо символ == КД::символи::Дія {
            якщо глибина == 0 {
              вивести_кд(М, "\\д");
            } інакше {
                вивести_кольорово(М, КолірВиводуЗелений, "\\д");
            }
          } інакше {
            якщо глибина == 0 {
              вивести_кд(М, кд { символ::адреса як *п8, 1 });
            } інакше {
              вивести_кольорово(М, КолірВиводуЗелений, кд { символ::адреса як *п8, 1 });
            }
          }

          п += 1;
        }
      }

      якщо глибина != 0 {
        вивести_кольорово(М, КолірВиводуЗелений, "\"");
      }

      вернути;
    }

    якщо предмет.клас == М.клас_Дія {
      змінна властивості = предмет як *ПредметДії;

      якщо властивості.назва == пусто {
        вивести_кольорово(М, КолірВиводуСиній, "<дія>");
      } інакше {
        вивести_кольорово(М, КолірВиводуСиній, "<дія ");

        вивести_кольорово(М, КолірВиводуСиній, властивості.назва.значення);

        вивести_кольорово(М, КолірВиводуСиній, ">");
      }

      вернути;
    }

    якщо предмет.клас == М.клас_Параметр {
      змінна предмет_параметра = предмет як *ПредметПараметра;
      вивести_кольорово(М, КолірВиводуСиній, "Параметр");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "назва=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_параметра.назва), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "тип=");
      якщо предмет_параметра.тип == пусто {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      } інакше {
        вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_параметра.тип), розмір_відступу, глибина + 1);
      }
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      вивести_значення_1(М, виведені_предмети, предмет_параметра.значення, розмір_відступу, глибина + 1);
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_Ознака {
      змінна предмет_ознаки = предмет як *ПредметОзнаки;
      вивести_кольорово(М, КолірВиводуСиній, "Ознака");
      вивести_кд(М, "(");
      якщо розмір_відступу > 0 {
        вивести_кд(М, "\р");
      }

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "назва=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_ознаки.назва), розмір_відступу, глибина + 1);
      вивести_кд(М, ",");
      якщо розмір_відступу > 0 {
        вивести_кд(М, "\р");
      } інакше {
        вивести_кд(М, " ");
      }

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "тип=");
      якщо предмет_ознаки.тип == пусто {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      } інакше {
        вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_ознаки.тип), розмір_відступу, глибина + 1);
      }
      вивести_кд(М, ",");
      якщо розмір_відступу > 0 {
        вивести_кд(М, "\р");
      } інакше {
        вивести_кд(М, " ");
      }

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      вивести_значення_1(М, виведені_предмети, предмет_ознаки.значення, розмір_відступу, глибина + 1);
      якщо розмір_відступу > 0 {
        вивести_кд(М, "\р");
      }

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_Код {
      змінна предмет_коду = предмет як *ПредметКоду;
      вивести_кольорово(М, КолірВиводуСиній, "Код");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "константи=");
      якщо предмет_коду.константи == пусто {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      } інакше {
        вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_коду.константи), розмір_відступу, глибина + 1);
      }
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "вказівки=");
      якщо предмет_коду.вказівки == пусто {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      } інакше {
        вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_коду.вказівки), розмір_відступу, глибина + 1);
      }
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "шлях=");
      якщо предмет_коду.шлях == пусто {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      } інакше {
        вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_коду.шлях), розмір_відступу, глибина + 1);
      }
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "місцезнаходження_вказівок=");
      вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_Список {
      змінна властивості_списку = предмет як *ПредметСписку;

      якщо предмет_вже_виведено(виведені_предмети, предмет) {
        вивести_кд(М, "[...]");
        вернути;
      }

      змінна свп = зберегти_стан_виведених_предметів(виведені_предмети);
      покласти_виведений_предмет(М, виведені_предмети, предмет);

      вивести_кд(М, "[");

      якщо властивості_списку.розмір > 0 {
        якщо розмір_відступу > 0 {
          вивести_кд(М, "\р");
        }

        змінна п: природне = 0;
        поки п < властивості_списку.розмір {
          змінна елемент = властивості_списку.елементи[п];
          вивести_пропуски(М, розмір_відступу * (глибина + 1));
          вивести_значення_1(М, виведені_предмети, елемент, розмір_відступу, глибина + 1);
          вивести_кд(М, ",");
          якщо розмір_відступу > 0 {
            вивести_кд(М, "\р");
          } інакше {
            вивести_кд(М, " ");
          }

          п += 1;
        }

        вивести_пропуски(М, розмір_відступу * глибина);
      }

      вивести_кд(М, "]");

      відновити_стан_виведених_предметів(виведені_предмети, свп);

      вернути;
    }

    якщо предмет.клас == М.клас_Словник {
      змінна властивості_словника = предмет як *ПредметСловника;

      якщо предмет_вже_виведено(виведені_предмети, предмет) {
        вивести_кд(М, "{...}");
        вернути;
      }

      змінна свп = зберегти_стан_виведених_предметів(виведені_предмети);
      покласти_виведений_предмет(М, виведені_предмети, предмет);

      вивести_кд(М, "{");

      якщо властивості_словника.розмір > 0 {
        якщо розмір_відступу > 0 {
          вивести_кд(М, "\р");
        }

        змінна п: природне = 0;
        поки п < властивості_словника.розмір {
          змінна пара = властивості_словника.елементи[п];
          вивести_пропуски(М, розмір_відступу * (глибина + 1));
          вивести_значення_1(М, виведені_предмети, пара.ключ, розмір_відступу, глибина + 1);
          вивести_кд(М, " => ");
          вивести_значення_1(М, виведені_предмети, пара.значення, розмір_відступу, глибина + 1);
          вивести_кд(М, ",");
          якщо розмір_відступу > 0 {
            вивести_кд(М, "\р");
          } інакше {
            вивести_кд(М, " ");
          }

          п += 1;
        }

        вивести_пропуски(М, розмір_відступу * глибина);
      }

      вивести_кд(М, "}");

      відновити_стан_виведених_предметів(виведені_предмети, свп);

      вернути;
    }

    якщо предмет.клас == М.клас_Дані {
      змінна предмет_даних = предмет як *ПредметДаних;
      вивести_кольорово(М, КолірВиводуСиній, "Дані");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "розмір=");
      вивести_значення_1(М, виведені_предмети, ЧИСЛО(р64(предмет_даних.розмір)), розмір_відступу, глибина + 1);
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_ПроміжокЧисел {
      змінна предмет_проміжка_чисел = предмет як *ПредметПроміжкаЧисел;
      вивести_кольорово(М, КолірВиводуСиній, "ПроміжокЧисел");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "від=");
      вивести_значення_1(М, виведені_предмети, ЧИСЛО(р64(предмет_проміжка_чисел.від)), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "до=");
      вивести_значення_1(М, виведені_предмети, ЧИСЛО(р64(предмет_проміжка_чисел.до)), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "включно=");
      якщо предмет_проміжка_чисел.включно {
        вивести_кольорово(М, КолірВиводуЖовтий, "дійсне");
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірПроміжкаЧисел {
      змінна предмет_перебору_проміжка_чисел = предмет як *ПредметПереборуПроміжкаЧисел;
      вивести_кольорово(М, КолірВиводуСиній, "ПеребірПроміжкаЧисел");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "проміжок=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_перебору_проміжка_чисел.предмет_проміжка), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      якщо предмет_перебору_проміжка_чисел.почато {
        вивести_значення_1(М, виведені_предмети, ЧИСЛО(предмет_перебору_проміжка_чисел.поточне_значення), розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірДаних {
      змінна предмет_перебору_даних = предмет як *ПредметПереборуДаних;
      вивести_кольорово(М, КолірВиводуСиній, "ПеребірДаних");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "дані=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_перебору_даних.предмет_даних), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      якщо предмет_перебору_даних.почато {
        вивести_значення_1(М, виведені_предмети, ЧИСЛО(предмет_перебору_даних.поточне_значення), розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "позиція=");
      якщо предмет_перебору_даних.почато {
        вивести_значення_1(М, виведені_предмети, ЧИСЛО(р64(предмет_перебору_даних.позиція)), розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірПослідовності {
      змінна предмет_перебору_послідовності = предмет як *ПредметПереборуПослідовності;
      вивести_кольорово(М, КолірВиводуСиній, "ПеребірПослідовності");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "послідовність=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_перебору_послідовності.предмет_послідовності), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      якщо предмет_перебору_послідовності.почато {
        вивести_значення_1(М, виведені_предмети, предмет_перебору_послідовності.поточне_значення, розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "позиція=");
      якщо предмет_перебору_послідовності.почато {
        вивести_значення_1(М, виведені_предмети, ЧИСЛО(р64(предмет_перебору_послідовності.позиція)), розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірСловника {
      змінна предмет_перебору_словника = предмет як *ПредметПереборуСловника;
      вивести_кольорово(М, КолірВиводуСиній, "ПеребірСловника");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "словник=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_перебору_словника.предмет_словника), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      якщо предмет_перебору_словника.почато {
        вивести_значення_1(М, виведені_предмети, предмет_перебору_словника.поточне_значення, розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірСписку {
      змінна предмет_перебору_списку = предмет як *ПредметПереборуСписку;
      вивести_кольорово(М, КолірВиводуСиній, "ПеребірСписку");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "список=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_перебору_списку.предмет_списку), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      якщо предмет_перебору_списку.почато {
        вивести_значення_1(М, виведені_предмети, предмет_перебору_списку.поточне_значення, розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "позиція=");
      якщо предмет_перебору_списку.почато {
        вивести_значення_1(М, виведені_предмети, ЧИСЛО(р64(предмет_перебору_списку.позиція)), розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірТексту {
      змінна предмет_перебору_тексту = предмет як *ПредметПереборуТексту;
      вивести_кольорово(М, КолірВиводуСиній, "ПеребірТексту");
      вивести_кд(М, "(\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "текст=");
      вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_перебору_тексту.предмет_тексту), розмір_відступу, глибина + 1);
      вивести_кд(М, ",\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "значення=");
      якщо предмет_перебору_тексту.почато {
        вивести_значення_1(М, виведені_предмети, ЧИСЛО(предмет_перебору_тексту.поточне_значення), розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * (глибина + 1));
      вивести_кд(М, "позиція=");
      якщо предмет_перебору_тексту.почато {
        вивести_значення_1(М, виведені_предмети, ЧИСЛО(р64(предмет_перебору_тексту.позиція)), розмір_відступу, глибина + 1);
      } інакше {
        вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");
      }
      вивести_кд(М, "\р");

      вивести_пропуски(М, розмір_відступу * глибина);
      вивести_кд(М, ")");
      вернути;
    }

    якщо предмет.клас == М.клас_Послідовність {
      змінна предмет_послідовності = предмет як *ПредметПослідовності;

      якщо предмет_вже_виведено(виведені_предмети, предмет) {
        вивести_кд(М, "(...)");
        вернути;
      }

      змінна свп = зберегти_стан_виведених_предметів(виведені_предмети);
      покласти_виведений_предмет(М, виведені_предмети, предмет);

      вивести_кд(М, "(");

      якщо предмет_послідовності.розмір > 0 {
        якщо розмір_відступу > 0 {
          вивести_кд(М, "\р");
        }

        змінна п: природне = 0;
        поки п < предмет_послідовності.розмір {
          змінна елемент = предмет_послідовності.елементи[п];
          вивести_пропуски(М, розмір_відступу * (глибина + 1));
          вивести_значення_1(М, виведені_предмети, елемент, розмір_відступу, глибина + 1);
          вивести_кд(М, ",");
          якщо п + 1 < предмет_послідовності.розмір {
            якщо розмір_відступу > 0 {
              вивести_кд(М, "\р");
            } інакше {
              вивести_кд(М, " ");
            }
          }

          п += 1;
        }

        якщо розмір_відступу > 0 {
          вивести_кд(М, "\р");
        }
        вивести_пропуски(М, розмір_відступу * глибина);
      }

      вивести_кд(М, ")");

      відновити_стан_виведених_предметів(виведені_предмети, свп);

      вернути;
    }

    вивести_кд(М, "<невідомо>");
  }

  структура ДаніДіїПереборуВиводуВластивостейПредмета {
    предмет: *Предмет;
    виведені_предмети: *Накопичувач<*Предмет>;
    виведені_властивості: *Накопичувач<*ПредметТексту>;
    розмір_відступу: природне;
    глибина: природне;
    щось_виведено: *логічне;
  }

  внутрішня дія дія_перебору_виводу_властивостей_предмета(
    М: *Машина,
    призначення: Призначення,
    назва: *ПредметТексту,
    значення: Значення,
    аргумент: адреса
  ) -> логічне {
    змінна дані = аргумент як *ДаніДіїПереборуВиводуВластивостейПредмета;
    змінна предмет = дані.предмет;
    змінна виведені_предмети = дані.виведені_предмети;
    змінна виведені_властивості = дані.виведені_властивості;
    змінна розмір_відступу = дані.розмір_відступу;
    змінна глибина = дані.глибина;

    змінна п: природне = 0;

    поки п < виведені_властивості.розмір {
      якщо порівняти_тексти(М, назва, виведені_властивості.дані[п]) {
        вернути так;
      }

      п += 1;
    }

    якщо не дані.щось_виведено::вміст {
      якщо розмір_відступу > 0 {
        вивести_кд(М, "\р");
      }
    }

    дані.щось_виведено::вміст = так;

    вивести_пропуски(М, розмір_відступу * (глибина + 1));
    вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(назва), 0, 0);
    вивести_кд(М, "=");
    вивести_значення_1(М, виведені_предмети, значення, розмір_відступу, глибина + 1);
    вивести_кд(М, ",");
    якщо розмір_відступу > 0 {
      вивести_кд(М, "\р");
    } інакше {
      вивести_кд(М, " ");
    }

    вернути так;
  }


  внутрішня дія вивести_предмет(
    М: *Машина,
    виведені_предмети: *Накопичувач<*Предмет>,
    предмет: *Предмет,
    розмір_відступу: природне,
    глибина: природне
  ) {
    якщо предмет.клас.вбудований {
      вивести_вбудований_предмет(
        М,
        виведені_предмети,
        предмет,
        розмір_відступу,
        глибина
      );
      вернути;
    }

    якщо предмет.клас.назва == пусто {
      вивести_кольорово(М, КолірВиводуСиній, "<без_назви>");
    } інакше {
      вивести_кольорово(М, КолірВиводуСиній, предмет.клас.назва.значення);
    }

    якщо предмет_вже_виведено(виведені_предмети, предмет) {
      вивести_кд(М, "(...)");
      вернути;
    }

    змінна свп = зберегти_стан_виведених_предметів(виведені_предмети);
    покласти_виведений_предмет(М, виведені_предмети, предмет);

    вивести_кд(М, "(");

    змінна щось_виведено = ні;
    змінна виведені_властивості = зробити_накопичувач<*ПредметТексту>(М, предмет.клас.ознаки.розмір);

    якщо предмет.клас.ознаки.розмір > 0 {
      якщо розмір_відступу > 0 {
        вивести_кд(М, "\р");
      }

      змінна п: природне = 0;
      поки п < предмет.клас.ознаки.розмір {
        змінна ознака = предмет.клас.ознаки.елементи[п];
        змінна предмет_ознаки = ознака.дані як *Предмет як *ПредметОзнаки;

        виведені_властивості.покласти(М, предмет_ознаки.назва);

        змінна значення_властивості = отримати_властивість(М, ПРЕДМЕТ(предмет), предмет_ознаки.назва, Місцезнаходження { пусто, 0});
        вивести_пропуски(М, розмір_відступу * (глибина + 1));
        вивести_значення_1(М, виведені_предмети, ПРЕДМЕТ(предмет_ознаки.назва), 0, 0);
        вивести_кд(М, "=");
        вивести_значення_1(М, виведені_предмети, значення_властивості, розмір_відступу, глибина + 1);
        вивести_кд(М, ",");
        якщо розмір_відступу > 0 {
          вивести_кд(М, "\р");
        } інакше {
          вивести_кд(М, " ");
        }

        щось_виведено = так;

        п += 1;
      }
    }

    змінна дані_дпввп = ДаніДіїПереборуВиводуВластивостейПредмета {
      предмет,
      виведені_предмети,
      виведені_властивості::адреса,
      розмір_відступу,
      глибина,
      щось_виведено::адреса
    };

    перебрати_призначення(
      М,
      (предмет як *СкладенийПредмет).властивості,
      дія_перебору_виводу_властивостей_предмета,
      дані_дпввп::адреса
    );

    звільнити(М, виведені_властивості.дані);

    якщо щось_виведено {
      вивести_пропуски(М, розмір_відступу * глибина);
    }

    вивести_кд(М, ")");

    відновити_стан_виведених_предметів(виведені_предмети, свп);
  }

  // позначка: прохід по типах предметів
  внутрішня дія вивести_значення_1(
    М: *Машина,
    виведені_предмети: *Накопичувач<*Предмет>,
    значення: Значення,
    розмір_відступу: природне,
    глибина: природне
  ) {
    якщо значення.вид == ЗНедійсне {
      вивести_кольорово(М, КолірВиводуЖовтий, "недійсне");

      вернути;
    }

    якщо значення.вид == ЗДійсне {
      вивести_кольорово(М, КолірВиводуЖовтий, "дійсне");

      вернути;
    }

    якщо значення.вид == ЗЧисло {
      змінна значення_кд: кд;

      якщо перетворити_р64_в_кд(М, значення.дані як р64, значення_кд::адреса) {
        вивести_кольорово(М, КолірВиводуЖовтий, значення_кд);
      }

      звільнити(М, значення_кд.дані);

      вернути;
    }

    вивести_предмет(
      М,
      виведені_предмети,
      значення.дані як *Предмет,
      розмір_відступу,
      глибина
    );
  }

  // позначка: прохід по типах предметів
  дія вивести_значення(
    М: *Машина,
    значення: Значення,
    розмір_відступу: природне,
    глибина: природне
  ) {
    змінна виведені_предмети = зробити_накопичувач<*Предмет>(М, 32);

    вивести_значення_1(
      М,
      виведені_предмети::адреса,
      значення,
      розмір_відступу,
      глибина
    );

    звільнити(М, виведені_предмети.дані);
  }

  дія надрукувати_значення(М: *Машина, значення: Значення, розмір_відступу: природне, глибина: природне) {
    вивести_значення(
      М,
      значення,
      розмір_відступу,
      глибина
    );

    вивести_кд(М, "\р");
  }
}