ПредметСловника.ц

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

секція МаМа {
  дія нативна_дія_словника_чародія_отримати_елемент(предмет_нативної_дії: адреса<ПредметНативноїДії>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_я == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю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;
    поки п < предмет_словника.елементи.розмір {
      покласти_в_накопичувач<адреса<Предмет>>(М, предмет_списку_визначень.елементи::адреса, предмет_словника.елементи.елементи[п].ключ);
      п += 1;
    }
    вернути предмет_списку_визначень як адреса<Предмет>;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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