ПредметСписку.ц

взяти визначення МаМа;

секція МаМа {
  дія нативна_дія_списку_чародія_отримати_елемент(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_отримати_елемент\" не можна виконувати від від пусто") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_отримати_елемент\" можна виконувати лише від списку") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    змінна ціль знайдено_предмет_аргумента_ключа = ні;
    змінна ціль предмет_аргумента_ключа: адреса<Предмет> = пусто;
    якщо іменовані_аргументи != пусто {
      ціль елемент_ключа = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.ключ);
      якщо елемент_ключа != пусто {
        знайдено_предмет_аргумента_ключа = так;
        предмет_аргумента_ключа = елемент_ключа.значення;
      }
    }
    якщо знайдено_предмет_аргумента_ключа == ні {
      якщо аргументи != пусто {
        якщо аргументи.розмір > 0 {
          знайдено_предмет_аргумента_ключа = так;
          предмет_аргумента_ключа = аргументи.дані[0];
        }
      }
    }
    якщо знайдено_предмет_аргумента_ключа == ні {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"ключ\"") як адреса<Предмет>;
    }
    вернути предмет_списку_отримати_елемент(предмет_списку, М, предмет_аргумента_ключа);
  }

  дія нативна_дія_списку_чародія_змінити_елемент(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_змінити_елемент\" не можна виконувати від від пусто") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_змінити_елемент\" можна виконувати лише від списку") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    змінна ціль знайдено_предмет_аргумента_ключа = ні;
    змінна ціль предмет_аргумента_ключа: адреса<Предмет> = пусто;
    змінна ціль знайдено_предмет_аргумента_значення = ні;
    змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
    якщо іменовані_аргументи != пусто {
      ціль елемент_ключа = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.ключ);
      якщо елемент_ключа != пусто {
        знайдено_предмет_аргумента_ключа = так;
        предмет_аргумента_ключа = елемент_ключа.значення;
      }
      ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
      якщо елемент_значення != пусто {
        знайдено_предмет_аргумента_значення = так;
        предмет_аргумента_значення = елемент_значення.значення;
      }
    }
    якщо знайдено_предмет_аргумента_ключа == ні {
      якщо аргументи != пусто {
        якщо аргументи.розмір > 0 {
          знайдено_предмет_аргумента_ключа = так;
          предмет_аргумента_ключа = аргументи.дані[0];
        }
      }
    }
    якщо знайдено_предмет_аргумента_значення == ні {
      якщо аргументи != пусто {
        якщо аргументи.розмір > 1 {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = аргументи.дані[1];
        }
      }
    }
    якщо знайдено_предмет_аргумента_ключа == ні {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"ключ\"") як адреса<Предмет>;
    }
    якщо знайдено_предмет_аргумента_значення == ні {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
    }
    вернути предмет_списку_змінити_елемент(предмет_списку, М, предмет_аргумента_ключа, предмет_аргумента_значення);
  }

  дія нативна_дія_списку_чародія_видалити_елемент(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_видалити_елемент\" не можна виконувати від від пусто") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_видалити_елемент\" можна виконувати лише від списку") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    змінна ціль знайдено_предмет_аргумента_ключа = ні;
    змінна ціль предмет_аргумента_ключа: адреса<Предмет> = пусто;
    якщо іменовані_аргументи != пусто {
      ціль елемент_ключа = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.ключ);
      якщо елемент_ключа != пусто {
        знайдено_предмет_аргумента_ключа = так;
        предмет_аргумента_ключа = елемент_ключа.значення;
      }
    }
    якщо знайдено_предмет_аргумента_ключа == ні {
      якщо аргументи != пусто {
        якщо аргументи.розмір > 0 {
          знайдено_предмет_аргумента_ключа = так;
          предмет_аргумента_ключа = аргументи.дані[0];
        }
      }
    }
    якщо знайдено_предмет_аргумента_ключа == ні {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"ключ\"") як адреса<Предмет>;
    }
    вернути предмет_списку_видалити_елемент(предмет_списку, М, предмет_аргумента_ключа);
  }

  дія нативна_дія_списку_чародія_перебір(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    вернути предмет_списку_отримати_перебір(предмет_списку, М);
  }

  дія нативна_дія_списку_чародія_містить(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_містить\" не можна виконувати від від пусто") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Чародію списку \"чародія_містить\" можна виконувати лише від списку") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    змінна ціль знайдено_предмет_аргумента = ні;
    змінна ціль предмет_аргумента: адреса<Предмет> = пусто;
    якщо іменовані_аргументи != пусто {
      ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
      якщо елемент_значення != пусто {
        знайдено_предмет_аргумента = так;
        предмет_аргумента = елемент_значення.значення;
      }
    }
    якщо знайдено_предмет_аргумента == ні {
      якщо аргументи != пусто {
        якщо аргументи.розмір > 0 {
          знайдено_предмет_аргумента = так;
          предмет_аргумента = аргументи.дані[0];
        }
      }
    }
    якщо знайдено_предмет_аргумента == ні {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
    }
    вернути предмет_списку_містить(предмет_списку, М, предмет_аргумента);
  }

  дія нативна_дія_списку_додати(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет пусто не може виконати дію списку \"додати\"") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет не є списком") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    якщо іменовані_аргументи != пусто {
      ціль елемент_аргумента_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
      якщо елемент_аргумента_значення != пусто {
        покласти_в_накопичувач<адреса<Предмет>>(М, предмет_списку.елементи::адреса, елемент_аргумента_значення.значення);
        вернути пусто;
      }
    }
    якщо аргументи != пусто {
      якщо аргументи.розмір > 0 {
        ціль аргумент = аргументи.дані[0];
        покласти_в_накопичувач<адреса<Предмет>>(М, предмет_списку.елементи::адреса, аргумент);
        вернути пусто;
      }
    }
    покласти_в_накопичувач<адреса<Предмет>>(М, предмет_списку.елементи::адреса, пусто);
    вернути пусто;
  }

  дія нативна_дія_списку_забрати(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет пусто не може виконати дію списку \"забрати\"") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет не є списком") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    якщо предмет_списку.елементи.розмір != 0 {
      ціль останній_елемент = предмет_списку.елементи.дані[предмет_списку.елементи.розмір - 1];
      предмет_списку.елементи.розмір = предмет_списку.елементи.розмір - 1;
      вернути останній_елемент;
    }
    вернути пусто;
  }

  дія фільтрувати_список(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, д: адреса<Предмет>): предмет_або_стан_падіння {
    ціль новий_список = виділити_предмет_списку(М);
    зберегти_предмет(М, д);
    зберегти_предмет(М, новий_список як адреса<Предмет>);
    змінна ціль позиція: позитивне = 0;
    поки позиція < предмет_списку.елементи.розмір {
      ціль елемент = предмет_списку.елементи.дані[позиція];
      ціль аргументи = виділити_накопичувач<адреса<Предмет>>(М);
      покласти_в_накопичувач<адреса<Предмет>>(М, аргументи, елемент);
      ціль результат_д = предмет_виконати(д, М, пусто, аргументи, пусто);
      звільнити_накопичувач<адреса<Предмет>>(М, аргументи);
      якщо М.стан_падіння == позитивне(так) {
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        вернути результат_д;
      }
      якщо перевірити_чи_предмет_виражається_логічним_так(результат_д, М) {
        покласти_в_накопичувач<адреса<Предмет>>(М, новий_список.елементи::адреса, елемент);
      }
      позиція += 1;
    }
    видалити_збережений_предмет(М);
    видалити_збережений_предмет(М);
    вернути новий_список як адреса<Предмет>;
  }

  дія нативна_дія_списку_фільтрувати(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет пусто не може виконати дію списку \"фільтрувати\"") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет не є списком") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    якщо іменовані_аргументи != пусто {
      ціль елемент_аргумента_д = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.д);
      якщо елемент_аргумента_д != пусто {
        ціль д = елемент_аргумента_д.значення;
        вернути фільтрувати_список(предмет_списку, М, д);
      }
    }
    якщо аргументи != пусто {
      якщо аргументи.розмір > 0 {
        ціль д = аргументи.дані[0];
        вернути фільтрувати_список(предмет_списку, М, д);
      }
    }
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Недостатньо аргументів для виконання дії \"фільтрувати\"") як адреса<Предмет>;
  }

  дія знайти_в_списку(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, д: адреса<Предмет>): предмет_або_стан_падіння {
    зберегти_предмет(М, д);
    змінна ціль позиція: позитивне = 0;
    поки позиція < предмет_списку.елементи.розмір {
      ціль елемент = предмет_списку.елементи.дані[позиція];
      ціль аргументи = виділити_накопичувач<адреса<Предмет>>(М);
      покласти_в_накопичувач<адреса<Предмет>>(М, аргументи, елемент);
      ціль результат_д = предмет_виконати(д, М, пусто, аргументи, пусто);
      звільнити_накопичувач<адреса<Предмет>>(М, аргументи);
      якщо М.стан_падіння == позитивне(так) {
        видалити_збережений_предмет(М);
        вернути результат_д;
      }
      якщо перевірити_чи_предмет_виражається_логічним_так(результат_д, М) {
        видалити_збережений_предмет(М);
        вернути елемент;
      }
      позиція += 1;
    }
    видалити_збережений_предмет(М);
    вернути пусто;
  }

  дія нативна_дія_списку_знайти(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет пусто не може виконати дію списку \"знайти\"") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет не є списком") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    якщо іменовані_аргументи != пусто {
      ціль елемент_аргумента_д = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.д);
      якщо елемент_аргумента_д != пусто {
        ціль д = елемент_аргумента_д.значення;
        вернути знайти_в_списку(предмет_списку, М, д);
      }
    }
    якщо аргументи != пусто {
      якщо аргументи.розмір > 0 {
        ціль д = аргументи.дані[0];
        вернути знайти_в_списку(предмет_списку, М, д);
      }
    }
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Недостатньо аргументів для виконання дії \"знайти\"") як адреса<Предмет>;
  }

  дія знайти_позицію_в_списку(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, д: адреса<Предмет>): предмет_або_стан_падіння {
    зберегти_предмет(М, д);
    змінна ціль позиція: позитивне = 0;
    поки позиція < предмет_списку.елементи.розмір {
      ціль елемент = предмет_списку.елементи.дані[позиція];
      ціль аргументи = виділити_накопичувач<адреса<Предмет>>(М);
      покласти_в_накопичувач<адреса<Предмет>>(М, аргументи, елемент);
      ціль результат_д = предмет_виконати(д, М, пусто, аргументи, пусто);
      звільнити_накопичувач<адреса<Предмет>>(М, аргументи);
      якщо М.стан_падіння == позитивне(так) {
        видалити_збережений_предмет(М);
        вернути результат_д;
      }
      якщо перевірити_чи_предмет_виражається_логічним_так(результат_д, М) {
        видалити_збережений_предмет(М);
        вернути виділити_предмет_числа(М, д64(позиція)) як адреса<Предмет>;
      }
      позиція += 1;
    }
    видалити_збережений_предмет(М);
    вернути виділити_предмет_числа(М, М.система.негація_д64(М, 1.0)) як адреса<Предмет>;
  }

  дія нативна_дія_списку_знайти_позицію(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет пусто не може виконати дію списку \"знайти_позицію\"") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет не є списком") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    якщо іменовані_аргументи != пусто {
      ціль елемент_аргумента_д = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.д);
      якщо елемент_аргумента_д != пусто {
        ціль д = елемент_аргумента_д.значення;
        вернути знайти_позицію_в_списку(предмет_списку, М, д);
      }
    }
    якщо аргументи != пусто {
      якщо аргументи.розмір > 0 {
        ціль д = аргументи.дані[0];
        вернути знайти_позицію_в_списку(предмет_списку, М, д);
      }
    }
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Недостатньо аргументів для виконання дії \"знайти_позицію\"") як адреса<Предмет>;
  }

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

  дія нативна_дія_списку_перетворити(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет пусто не може виконати дію списку \"перетворити\"") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет не є списком") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    якщо іменовані_аргументи != пусто {
      ціль елемент_аргумента_д = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.д);
      якщо елемент_аргумента_д != пусто {
        ціль д = елемент_аргумента_д.значення;
        вернути перетворити_список(предмет_списку, М, д);
      }
    }
    якщо аргументи != пусто {
      якщо аргументи.розмір > 0 {
        ціль д = аргументи.дані[0];
        вернути перетворити_список(предмет_списку, М, д);
      }
    }
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Недостатньо аргументів для виконання дії \"перетворити\"") як адреса<Предмет>;
  }

  дія нативна_дія_списку_обернути(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет пусто не може виконати дію списку \"обернути\"") як адреса<Предмет>;
    }
    якщо предмет_я.тип != М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Предмет не є списком") як адреса<Предмет>;
    }
    ціль предмет_списку = предмет_я як адреса<ПредметСписку>;
    ціль новий_список = виділити_предмет_списку(М);
    змінна ціль позиція: позитивне = предмет_списку.елементи.розмір;
    поки позиція > 0 {
      позиція -= 1;
      ціль елемент = предмет_списку.елементи.дані[позиція];
      покласти_в_накопичувач<адреса<Предмет>>(М, новий_список.елементи::адреса, елемент);
    }
    вернути новий_список як адреса<Предмет>;
  }

  місцева дія створити_структуру_списку(М: адреса<Машина>): адреса<ПредметСтруктури> {
    ціль предмет_структури = виділити_предмет_структури(М, М.БН.С.список, М.предмет_структури_предмет);

    ціль предмет_нативної_дії_списку_чародія_отримати_елемент = виділити_предмет_нативної_дії(М, М.БН.С.чародія_отримати_елемент, нативна_дія_списку_чародія_отримати_елемент, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.чародія_отримати_елемент, предмет_нативної_дії_списку_чародія_отримати_елемент як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_чародія_змінити_елемент = виділити_предмет_нативної_дії(М, М.БН.С.чародія_змінити_елемент, нативна_дія_списку_чародія_змінити_елемент, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.чародія_змінити_елемент, предмет_нативної_дії_списку_чародія_змінити_елемент як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_чародія_видалити_елемент = виділити_предмет_нативної_дії(М, М.БН.С.чародія_видалити_елемент, нативна_дія_списку_чародія_видалити_елемент, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.чародія_видалити_елемент, предмет_нативної_дії_списку_чародія_видалити_елемент як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_чародія_перебір = виділити_предмет_нативної_дії(М, М.БН.С.чародія_перебір, нативна_дія_списку_чародія_перебір, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.чародія_перебір, предмет_нативної_дії_списку_чародія_перебір як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_чародія_містить = виділити_предмет_нативної_дії(М, М.БН.С.чародія_містить, нативна_дія_списку_чародія_містить, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.чародія_містить, предмет_нативної_дії_списку_чародія_містить як адреса<Предмет>);

    ціль предмет_нативної_дії_списку_додати = виділити_предмет_нативної_дії(М, М.БН.С.додати, нативна_дія_списку_додати, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.додати, предмет_нативної_дії_списку_додати як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_забрати = виділити_предмет_нативної_дії(М, М.БН.С.забрати, нативна_дія_списку_забрати, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.забрати, предмет_нативної_дії_списку_забрати як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_фільтрувати = виділити_предмет_нативної_дії(М, М.БН.С.фільтрувати, нативна_дія_списку_фільтрувати, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.фільтрувати, предмет_нативної_дії_списку_фільтрувати як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_знайти = виділити_предмет_нативної_дії(М, М.БН.С.знайти, нативна_дія_списку_знайти, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.знайти, предмет_нативної_дії_списку_знайти як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_знайти_позицію = виділити_предмет_нативної_дії(М, М.БН.С.знайти_позицію, нативна_дія_списку_знайти_позицію, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.знайти_позицію, предмет_нативної_дії_списку_знайти_позицію як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_перетворити = виділити_предмет_нативної_дії(М, М.БН.С.перетворити, нативна_дія_списку_перетворити, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.перетворити, предмет_нативної_дії_списку_перетворити як адреса<Предмет>);
    ціль предмет_нативної_дії_списку_обернути = виділити_предмет_нативної_дії(М, М.БН.С.обернути, нативна_дія_списку_обернути, пусто, пусто);
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, М.БН.С.обернути, предмет_нативної_дії_списку_обернути як адреса<Предмет>);

    вернути предмет_структури;
  }

  місцева дія виділити_предмет_списку(М: адреса<Машина>): адреса<ПредметСписку> {
    ціль предмет_списку = виділити_предмет<ПредметСписку>(М, М.предмет_структури_список);

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

    вернути предмет_списку;
  }

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

  місцева дія предмет_списку_виконати(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати список") як адреса<Предмет>;
  }

  місцева дія предмет_списку_отримати_властивість(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, назва: адреса<Назва>): предмет_або_стан_падіння {
    якщо назва == М.БН.С.довжина {
      вернути виділити_предмет_числа(М, д64(предмет_списку.елементи.розмір)) як адреса<Предмет>;
    }
    ціль елемент_реєстру = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, предмет_списку.властивості::адреса, назва);
    якщо елемент_реєстру != пусто {
      вернути елемент_реєстру.значення;
    }
    змінна ціль тип = предмет_списку.тип;
    поки тип != пусто {
      ціль елемент_реєстру_методів = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, тип.методи::адреса, назва);
      якщо елемент_реєстру_методів != пусто {
        вернути елемент_реєстру_методів.значення;
      }
      тип = тип.предок;
    }
    вернути пусто;
  }

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

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

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

  місцева дія предмет_списку_отримати_елемент(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, ключ: адреса<Предмет>): предмет_або_стан_падіння {
    якщо ключ == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Ключ отримання елемента зі списку має бути числом") як адреса<Предмет>;
    }
    якщо ключ.тип != М.предмет_структури_число {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Ключ отримання елемента зі списку має бути числом") як адреса<Предмет>;
    }
    ціль предмет_числа = ключ як адреса<ПредметЧисла>;
    ціль позиція = позитивне(предмет_числа.значення);
    якщо предмет_списку.елементи.розмір > позиція {
      вернути предмет_списку.елементи.дані[позиція];
    }
    вернути пусто;
  }

  місцева дія предмет_списку_змінити_елемент(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, ключ: адреса<Предмет>, значення: адреса<Предмет>): предмет_або_стан_падіння {
    якщо ключ == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Ключ для зміни елемента списку має бути числом") як адреса<Предмет>;
    }
    якщо ключ.тип != М.предмет_структури_число {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Ключ для зміни елемента списку має бути числом") як адреса<Предмет>;
    }
    ціль предмет_числа_ключа = ключ як адреса<ПредметЧисла>;
    ціль позиція = позитивне(предмет_числа_ключа.значення);
    якщо предмет_списку.елементи.розмір > позиція {
      предмет_списку.елементи.дані[позиція] = значення;
    } інакше {
      розширити_накопичувач<адреса<Предмет>>(М, предмет_списку.елементи::адреса, позиція + 1, пусто);
      предмет_списку.елементи.дані[позиція] = значення;
    }
    вернути пусто;
  }

  місцева дія предмет_списку_видалити_елемент(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, ключ: адреса<Предмет>): предмет_або_стан_падіння {
    якщо ключ == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Ключ видалення елемента зі списку має бути числом") як адреса<Предмет>;
    }
    якщо ключ.тип != М.предмет_структури_число {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Ключ видалення елемента зі списку має бути числом") як адреса<Предмет>;
    }
    ціль предмет_числа = ключ як адреса<ПредметЧисла>;
    ціль позиція = позитивне(предмет_числа.значення);
    якщо видалити_з_накопичувача<адреса<Предмет>>(М, предмет_списку.елементи::адреса, позиція) {
      вернути М.предмет_логічного_так як адреса<Предмет>;
    }
    вернути М.предмет_логічного_ні як адреса<Предмет>;
  }

  дія нативна_дія_перебору_списку_далі(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    ціль предмет_списку = предмет_отримати_властивість(предмет_я, М, М.БН.С.сп);
    зберегти_предмет(М, предмет_списку);
    якщо М.стан_падіння == позитивне(так) {
      видалити_збережений_предмет(М);
      вернути предмет_списку;
    }
    ціль довжина_списку = предмет_отримати_властивість(предмет_списку, М, М.БН.С.довжина);
    зберегти_предмет(М, довжина_списку);
    якщо М.стан_падіння == позитивне(так) {
      видалити_збережений_предмет(М);
      видалити_збережений_предмет(М);
      вернути довжина_списку;
    }
    змінна ціль предмет_позиції = предмет_отримати_властивість(предмет_я, М, М.БН.С.позиція);
    зберегти_предмет(М, предмет_позиції);
    якщо М.стан_падіння == позитивне(так) {
      видалити_збережений_предмет(М);
      видалити_збережений_предмет(М);
      видалити_збережений_предмет(М);
      вернути предмет_позиції;
    }
    ціль чи_позиція_менше = предмет_менше(предмет_позиції, М, довжина_списку);
    зберегти_предмет(М, чи_позиція_менше);
    якщо М.стан_падіння == позитивне(так) {
      видалити_збережений_предмет(М);
      видалити_збережений_предмет(М);
      видалити_збережений_предмет(М);
      видалити_збережений_предмет(М);
      вернути чи_позиція_менше;
    }
    якщо чи_позиція_менше == М.предмет_логічного_так як адреса<Предмет> {
      якщо М.стан_падіння == позитивне(так) {
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        вернути предмет_позиції;
      }
      ціль елемент_списку = предмет_отримати_елемент(предмет_списку, М, предмет_позиції);
      зберегти_предмет(М, чи_позиція_менше);
      якщо М.стан_падіння == позитивне(так) {
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        вернути елемент_списку;
      }
      предмет_позиції = предмет_додати(предмет_позиції, М, виділити_предмет_числа(М, 1) як адреса<Предмет>);
      зберегти_предмет(М, предмет_позиції);
      ціль результат_зміни_властивості_позиції = предмет_змінити_властивість(предмет_я, М, М.БН.С.позиція, предмет_позиції);
      якщо М.стан_падіння == позитивне(так) {
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        вернути результат_зміни_властивості_позиції;
      }
      ціль результат_зміни_властивості_значення = предмет_змінити_властивість(предмет_я, М, М.БН.С.значення, елемент_списку);
      якщо М.стан_падіння == позитивне(так) {
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        видалити_збережений_предмет(М);
        вернути результат_зміни_властивості_значення;
      }
      вернути М.предмет_логічного_так як адреса<Предмет>;
    }
    видалити_збережений_предмет(М);
    видалити_збережений_предмет(М);
    видалити_збережений_предмет(М);
    видалити_збережений_предмет(М);
    вернути М.предмет_логічного_ні як адреса<Предмет>;
  }

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

  місцева дія предмет_списку_додати(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати додавання для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_відняти(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати віднімання для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_помножити(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати множення для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_поділити(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати ділення для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_отримати_остачу_ділення(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати отримання остачі ділення для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_отримати_частку_ділення(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати отримання частки ділення для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_піднести_до_степеня(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати піднесення до степеня для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_зсунути_вліво(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зсув вліво для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_зсунути_вправо(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зсув вправо для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_зсунути_вправо_зі_заповненням(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зсув вправо зі заповненням для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_двійкове_і(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове І для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_двійкове_або(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове АБО для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_двійкове_виключне_або(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове виключне АБО для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_двійкове_не(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове НЕ для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_більше(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати перевірку на більшість для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_менше(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати перевірку на меншість для списку") як адреса<Предмет>;
  }

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

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

  місцева дія предмет_списку_є(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо аргумент == пусто {
      вернути М.предмет_логічного_ні як адреса<Предмет>;
    }
    якщо аргумент.тип != М.предмет_структури_Структура {
      вернути М.предмет_логічного_ні як адреса<Предмет>;
    }
    якщо перевірити_чи_предмет_списку_є(предмет_списку, М, аргумент як адреса<ПредметСтруктури>) {
      вернути М.предмет_логічного_так як адреса<Предмет>;
    }
    вернути М.предмет_логічного_ні як адреса<Предмет>;
  }

  місцева дія предмет_списку_відʼємне(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати відʼємне для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_числове(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати числове для списку") як адреса<Предмет>;
  }

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

  місцева дія предмет_списку_збільшити(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати збільшення для списку") як адреса<Предмет>;
  }

  місцева дія предмет_списку_зменшити(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зменшення для списку") як адреса<Предмет>;
  }

  місцева дія перевірити_чи_предмет_списку_рівно(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, аргумент: адреса<Предмет>): логічне {
    ціль предмет = предмет_списку як адреса<Предмет>;
    якщо предмет == аргумент {
      вернути так;
    }
    вернути ні;
  }

  місцева дія перевірити_чи_предмет_списку_є(предмет_списку: адреса<ПредметСписку>, М: адреса<Машина>, предмет_структури: адреса<ПредметСтруктури>): логічне {
    якщо предмет_структури == М.предмет_структури_список {
      вернути так;
    }
    вернути ні;
  }

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