Сложим 1011 и 0010
Возьмем последний бит второго слагаемого (0)
Прибавим его к 1011, получим 1011, сохраним последний бит результата (1)
Осталось сложить 101 и 001
Возьмем последний бит второго слагаемого (1)
Прибавим его к 101, получим 110, сохраним последний бит результата (0)
Осталось сложить 11 и 00
...
Склеим все сохраненные биты: 1,1,0,1
В результате получаем 1101

# Сохраненные биты будем хранить через пробел от первого слагаемого.
s/\([01]*\)+\([01]*\)$/\1 \n\2/
:add::loop
	# если во втором слагаемом последний бит — 0, то пропускаем сложение. 
	/0$/ b add::continueloop

	# если там единица, то прибавим ее к первому слагаемому, это мы умеем!
	:add::_replaceloop
		s/\([01]*\)1\(_*\) \([01]*\)\n\([01]*\)$/\1_\2 \3\n\4/
		/[01]*1_* [01]*\n[01]*$/ b add::_replaceloop
	s/\([01]*\)0\(_*\) \([01]*\)\n\([01]*\)$/\11\2 \3\n\4/
	:add::_reversereplaceloop
		s/\([01]*\)_\([^\n ]*\) \([01]*\)\n\([01]*\)$/\10\2 \3\n\4/
		/[01]*_[01 _]*\n[01]*$/ b add::_reversereplaceloop

	:add::continueloop
	# сохраним очередной бит, удалим последний обработанный бит
	s/\([01]*\)\([01]\) \([01]*\)\n\([01]*\).$/\1 \2\3\n\4/
    # продолжаем, пока во втором слагаемом есть биты
    /[01]$/ b add::loop	
# чистим артефакты — лишний пробел в начале и лишний перенос в конце
s/ \([^\n]*\)\n$/\1/

# Инвертируем биты вычитаемого: меняем 1 на _, потом 0 на 1, потом _ на 0
sub::1_loop
	s/1\([0_]*\)$/_\1/
	/1[0_]*$/ b sub::1_loop
:sub::01loop
	s/0\([_1]*\)$/1\1/
	/0[_1]*$/ b sub::01loop
:sub::_0loop
	s/_\([10]*\)$/0\1/
	/_[10]*$/ b sub::_0loop

# Прибавим к инвертированному числу единицу
:sub::_replaceloop
	s/\([01]*\)1\(_*\)$/\1_\2/
	/[01]*1_*$/ b sub::_replaceloop
s/0\(_*\)$/1\1/
:sub::_reversereplaceloop
	s/\([01]*\)_\([^\n ]*\)$/\10\2/
	/[01]*_[01_]*$/ b sub::_reversereplaceloop

# Меняем минус на плюс в выражении
s/-\([01]*\)$/+\1/

# А дальше — просто складываем, это мы уже умеем! 
s/\([01]*\)+\([01]*\)$/\1 \n\2/
:add::loop
  /0$/ b add::continueloop

  :add::_replaceloop
    s/\([01]*\)1\(_*\) \([01]*\)\n\([01]*\)$/\1_\2 \3\n\4/
    /[01]*1_* [01]*\n[01]*/ b add::_replaceloop 
 
  s/\([01]*\)0\(_*\) \([01]*\)\n\([01]*\)$/\11\2 \3\n\4/ 
 
  :add::_reversereplaceloop 
    s/\([01]*\)_\([^\n ]*\) \([01]*\)\n\([01]*\)$/\10\2 \3\n\4/ 
    /[01]*_[01 _]*\n[01]*$/ b add::_reversereplaceloop 
 
  :add::continueloop 
  s/\([01]*\)\([01]\) \([01]*\)\n\([01]*\).$/\1 \2\3\n\4/ 
/[01]$/ b add::loop 
s/ \([^\n]*\)\n$/\1/

# Инициализация стека
x ; s/$/\ncall_stack = ,/ ; x 

# Первый вызов функции 
x ; s/\(call_stack = [^\n]*\)/\1,first_label/ ; x
b func
:first_label

# Второй вызов функции
x ; s/\(call_stack = [^\n]*\)/\1,second_label/ ; x
b func
:second_label

p ; q # Распечатаем pattern space и выйдем из скрипта

# Функция добавляет в pattern space строчку 'function called'
# В итоге в буфере будет столько строчек, сколько раз мы ее вызвали
:func
{
  s/$/\nfunction called/
  b return
}

# Обработчик возвратов. 
:return
{
  # Переходим в hold space
  x 
  # Код перехода к метке first_label. Удаляем из стека последнюю метку, переключаемся в pattern space и переходим на метку first_label
  /call_stack = [^\n]*,first_label\n/ { s/\(call_stack = [^\n]*\),[^\n,]*/\1/ ; x ; b first_label ; }
  # Код перехода к метке second_label. Фактически копипаста
  /call_stack = [^\n]*,second_label\n/ { s/\(call_stack = [^\n]*\),[^\n,]*/\1/ ; x ; b second_label ; }
}

:set
{
  # Перекинем содержимое последней строки вверх, поставив перед ним строчку ':set'
  s/\([^\n]*\)$/:set\n\1/
  s/^\(.*\)\(:set\n[^\n]*\)$/\2\n\1/
  s/\n$//
  # Допишем содержимое основного буфера во вспомогательный
  H
  # Удалим артефакты в начале основного буфера
  s/^:set\n[^\n]*\n*//
  # Переключимся на hold space
  x
  # Сотрем лишние (вторая и далее) строки после уникальной метки ':set' (и ее саму тоже)
  # Содержательную строчку перенесем в начало
  s/^\(.*\)\n:set\n\([^\n]*\).*$/\2\n\1/
  # Отыщем строчку со старым значением переменной и удалим ее
  s/^\([^\n= ]*\) = \([^\n]*\)\n\(.*\)\1 = [^\n]*\(.*\)$/\3\1 = \2\4/
  # Переключимся обратно в основной буфер
  x
  b return
}

:get
{
  # Перекинем содержимое последней строки вверх, поставив перед ним строчку ':get'
  s/\([^\n]*\)$/:get\n\1/
  s/^\(.*\)\(:get\n[^\n]*\)$/\2\n\1/
  s/\n$//
  # Допишем содержимое основного буфера во вспомогательный
  H
  # Удалим артефакты в начале основного буфера
  s/^:get\n[^\n]*\n*//
  # Переключимся на hold space
  x
  # Сотрем лишние (вторая и далее) строки после уникальной метки ':get' (и ее саму тоже)
  # Содержательную строчку перенесем в начало
  s/^\(.*\)\n:get\n\([^\n]*\).*$/\2\n\1/
  # Отыщем нужную переменную и запишем ее значение в первую строку. В начале буфера снова поставим метку ':get' 
  s/^\([^\n]*\)\n\(.*\)\1 = \([^\n]*\)/:get\n\3\n\2\1 = \3/
  # Допишем содержимое hold space в pattern space
  H
  # Удалим артефакты (две верхние строки) из hold space
  s/^:get\n[^\n]*\n\(.*\)$/\1/
  # Переключимся обратно в основной буфер
  x
  # Пользуясь уникальной меткой, удалим лишнее, оставив только старое содержимое буфера и прочитанное значение переменной
  s/^\n*\(.*\)\n:get\n\([^\n]*\).*$/\1\n\2/
  b return
}

:copy
{
  s/\([^\n]*\)$/:copy\n\1/
  s/^\(.*\)\(:copy\n[^\n]*\)$/\2\n\1/
  s/\n$//
  H
  s/^:copy\n[^\n]*\n*//
  x
  s/^\(.*\)\n:copy\n\([^\n]*\).*$/\2\n\1/
  s/^\([^ ]*\) = \([^\n]*\)\n\(.*\)\2 = \([^\n]*\)/\1 = \4\n\3\2 = \4/
  s/^\([^ ]*\) = \([^\n]*\)\n\(.*\)\1 = [^\n]*/\3\1 = \2/
  x
  b return
}

:add
{
  # Чтение слагаемых
  s/$/\nadd::first_operand/
  x ; s/\(call_stack = [^\n]*\)/\1,add::get1/ ; x
  b get
  :add::get1

  s/$/\nadd::second_operand/
  x ; s/\(call_stack = [^\n]*\)/\1,add::get2/ ; x
  b get
  :add::get2

  # Подготовка к сложению
  s/\([01]*\)\n\([01]*\)$/\1 \n\2/
	
  # Цикл сложения, тут ничего нового
  :add::loop
    /0$/ b add::continueloop

    :add::_replaceloop
      s/\([01]*\)1\(_*\) \([01]*\)\n\([01]*\)$/\1_\2 \3\n\4/
      /[01]*1_* [01]*\n[01]*$/ b add::_replaceloop

    s/\([01]*\)0\(_*\) \([01]*\)\n\([01]*\)$/\11\2 \3\n\4/

    :add::_reversereplaceloop
      s/\([01]*\)_\([^\n ]*\) \([01]*\)\n\([01]*\)$/\10\2 \3\n\4/
      /[01]*_[01 _]*\n[01]*$/ b add::_reversereplaceloop
    :add::continueloop

    s/\([01]*\)\([01]\) \([01]*\)\n\([01]*\).$/\1 \2\3\n\4/
  /[01]$/ b add::loop	

  # Запись результата
  s/ \([^\n]*\)\n$/add::result = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,add::result/ ; x
  b set
  :add::result
	
  b return
}

:sub
{
  # Чтение операндов (из тех же переменных)
  s/$/\nadd::second_operand/
  x ; s/\(call_stack = [^\n]*\)/\1,sub::get1/ ; x
  b get
  :sub::get1

  # Инвертируем биты
  :sub::1_loop
    s/1\([0_]*\)$/_\1/
    /1[0_]*$/ b sub::1_loop
  :sub::01loop
    s/0\([_1]*\)$/1\1/
    /0[_1]*$/ b sub::01loop
  :sub::_0loop
    s/_\([10]*\)$/0\1/
    /_[10]*$/ b sub::_0loop

  # Инкремент
  :sub::_replaceloop
    s/\([01]*\)1\(_*\)$/\1_\2/
    /[01]*1_*$/ b sub::_replaceloop
  s/0\(_*\)$/1\1/
  :sub::_reversereplaceloop
    s/\([01]*\)_\([^\n ]*\)$/\10\2/
    /[01]*_[01_]*$/ b sub::_reversereplaceloop

  # Перезаписываем переменную
  s/\([^\n]*\)$/add::second_operand = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,sub::set1/ ; x
  b set
  :sub::set1

  # Переходим к сложению.
  b add
}

:mul
{
  # Читаем множители зи переменных
  s/$/\nmul::first_operand/
  x ; s/\(call_stack = [^\n]*\)/\1,mul::get1/ ; x
  b get
  :mul::get1
	
  s/$/\nmul::second_operand/
  x ; s/\(call_stack = [^\n]*\)/\1,mul::get2/ ; x
  b get
  :mul::get2
	
  # Инициализируем результат нулем нужной битности
  s/\([01]*\)$/\1\n\1/
  :mul::init_loop
  s/1\(0*\)$/0\1/
  /10*$/ b mul::init_loop

  # Будем умножать в цикле бит за битом 
  :mul::loop
    /0\n[01]*$/ b mul::shift

    # Подготовимся к сложению. Первое слагаемое — это текущий результат
    s/\([01]*\)$/\1\nadd::first_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,mul::prepare_intermediate_result_1/ ; x
    b set
    :mul::prepare_intermediate_result_1

    # Второе слагаемое — это текущее значение первого множителя
    s/\([01]*\)\n\([01]*\)\n\([01]*\)$/\1\n\2\n\3\nadd::second_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,mul::prepare_intermediate_result_2/ ; x
    b set
    :mul::prepare_intermediate_result_2

    # Выполним сложение
    x ; s/\(call_stack = [^\n]*\)/\1,mul::calculate_intermediate_result/ ; x
    b add
    :mul::calculate_intermediate_result

    # Обновим текущий результат
    s/[01]*$/add::result/
    x ; s/\(call_stack = [^\n]*\)/\1,mul::get_intermediate_result/ ; x
    b get
	:mul::get_intermediate_result
      
    :mul::shift
    # Умножим первый множитель на 2 (через битовый сдвигом на 1)
    s/[01]\([01]*\)\n\([01]*\)\n\([01]*\)$/\10\n\2\n\3/
    
    # Удалим последний бит второго множителя
    s/\([01]*\)[01]\n\([01]*\)$/\1\n\2/
    /\n\n[01]*$/ b mul::end_loop
    b mul::loop
  
  :mul::end_loop

  # Запишем финальный результат в переменную mul::result
  s/\([^\n]*\)$/mul::result = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,mul::result/ ; x
  b set
  :mul::result

  # Чистим артефакты. Можно было и выше сделать, это чисто для ясности
  s/\n*[01]*\n$//
  
  b return
}

# Если строки одинаковы, то и числа одинаковы
/\([01]*\)\n\1$/ b equal

# Поставим пробелы перед обоими числами
s/\([01]*\)\n\([01]*\)$/ \1\n \2/

:compare_loop
  # Выделим первый бит после пробела, поставим его перед пробелом
  s/[01]* \([01]\)\([01]*\)\n[01]* \([01]\)\([01]*\)$/\1 \2\n\3 \4/
  /0 [01]*\n1 [01]*$/ b less
  /1 [01]*\n0 [01]*$/ b greater
  b compare_loop

:div
{
  # Читаем делимое и делитель
  s/$/\ndiv::first_operand/
  x ; s/\(call_stack = [^\n]*\)/\1,div::get1/ ; x
  b get
  :div::get1

  s/$/\ndiv::second_operand/
  x ; s/\(call_stack = [^\n]*\)/\1,div::get2/ ; x
  b get
  :div::get2

  # Определим также старший бит делимого: поставим пробел после ведущих нулей
  s/\(0*\)\([01]*\)\n\([01]*\)$/\1 \2\n\3\n\1 \2\n\1\2/
  # Инициализируем частное и остаток нулями нужной битности.
  :div::init_loop
    # Заменим очередной символ "1" на "0" в частном
    s/\([0 ]*\)1\([01]*\)\n\([01]*\)$/\10\2\n\3/
    # ... а потом — в остатке.
    s/\(0*\)1\([01]*\)$/\10\2/
    # Продолжаем, пока остаются символы "1"
    /0*1[01]*\n[01]*$/ b div::init_loop
    /0*1[01]*$/ b div::init_loop

  # Основной цикл деления
  :div::loop
    # Умножим остаток на 2, присвоим его младшему биту значение старшего бита делимого
    s/\([01]*\) \([01]\)\([01]*\)\n\([01]*\)\n\([01 ]*\)\n[01]\([01]*\)$/\1 \2\3\n\4\n\5\n\6\2/
   
   	# Процедура сравнения остатка и делителя.
   	# Скопируем оба числа
    s/\([01]*\)\n\([01 ]*\)\n\([01]*\)$/\1\n\2\n\3\n \1\n \3/
	
    # При равенстве чистим артефакты и переходим к вычитанию
    /\([01 ]*\)\n\1$/ { s/\n[01 ]*\n[01 ]*$// ; b div::sub ; }

    # То же самое, если остаток больше делителя.
    # В противном случае просто очистим артефакты и пропустим шаг вычитания
    :div::compare_loop
      s/[01]* \([01]\)\([01]*\)\n[01]* \([01]\)\([01]*\)$/\1 \2\n\3 \4/
      /0 [01]*\n1 [01]*$/ { s/\n[01 ]*\n[01 ]*$// ; b div::sub ; }
      /1 [01]*\n0 [01]*$/ { s/\n[01 ]*\n[01 ]*$// ; b div::subend ; }
      b div::compare_loop

	# Цикл вычитания
    :div::sub
      # Задаем операнды
      # Уменьшаемое := остаток
      s/\([^\n]*\)$/\1\nadd::first_operand = \1/
      x ; s/\(call_stack = [^\n]*\)/\1,div::prepare_sub_1/ ; x
      b set
      :div::prepare_sub_1

      # Вычитаемое := делитель
      s/\([01]*\)\n\([01 ]*\)\n\([01]*\)$/\1\n\2\n\3\nadd::second_operand = \1/
      x ; s/\(call_stack = [^\n]*\)/\1,div::prepare_sub_2/ ; x
      b set
      :div::prepare_sub_2

      # Выполняем вычитание 
      x ; s/\(call_stack = [^\n]*\)/\1,div::execute_sub/ ; x
      b sub
      :div::execute_sub
 
      # Обновляем значение остатка
      s/[01]*$/add::result/
      x ; s/\(call_stack = [^\n]*\)/\1,div::set_remainder/ ; x
      b get
      :div::set_remainder

      # Выставляем в единицу соответствующий бит частного
      s/ 0\([01]*\)\n\([01]*\)$/ 1\1\n\2/

    :div::subend
    # Сохраняем очередной бит делимого и частного, продолжаем, пока остаются биты
    s/\([01]*\) \([01]\)\([01]*\)\n\([01]*\)\n\([01]*\) \([01]\)\([01]*\)\n\([01]*\)$/\1\2 \3\n\4\n\5\6 \7\n\8/
    /[01]\n[01]*$/ b div::loop

  # Удаляем из частного пробел
  s/ \n\([01]*\)$/\n\1/

  # Чистим артефакты
  s/[01 ]*\n[01]*\n\([01]*\)\n\([01]*\)$/\1\n\2/

  # Запишем результат (остаток и частное) в переменные
  s/\([01]*\)$/div::mod_result = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,div::result_1/ ; x
  b set
  :div::result_1

  s/\([^\n]*\)$/div::div_result = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,div::result_2/ ; x
  b set
  :div::result_2

  b return
} 

# Инициализируем стек вызовов
s/^.*$/call_stack = / 

# Инициализируем константы ГСЧ
s/$/\nrng::current_state = 00000000000000000000000000000000/
s/$/\nrng::A = 00000000000000000000010101010110/ # A = 1366
s/$/\nrng::C = 00000000000000100100110101101001/ # C = 150889
s/$/\nrng::M = 00000000000010101110010100101001/ # M = 714025

# Запишем все в hold space, очистим pattern space
h ; s/^.*$//

:rng
{
  # Зададим операнды умножения
  s/$/\nmul::first_operand = rng::A/
  x ; s/\(call_stack = [^\n]*\)/\1,rng::mul_set_1/ ; x
  b copy
  :rng::mul_set_1

  s/$/\nmul::second_operand = rng::current_state/
  x ; s/\(call_stack = [^\n]*\)/\1,rng::mul_set_2/ ; x
  b copy
  :rng::mul_set_2

  # Выполним умножение
  x ; s/\(call_stack = [^\n]*\)/\1,rng::execute_mul/ ; x
  b mul
  :rng::execute_mul

  # Зададим операнды сложения
  s/$/\nadd::first_operand = mul::result/
  x ; s/\(call_stack = [^\n]*\)/\1,rng::add_set_1/ ; x
  b copy
  :rng::add_set_1

  s/$/\nadd::second_operand = rng::C/
  x ; s/\(call_stack = [^\n]*\)/\1,rng::add_set_2/ ; x 
  b copy
  :rng::add_set_2

  # Выполним сложение
  x ; s/\(call_stack = [^\n]*\)/\1,rng::execute_add/ ; x
  b add
  :rng::execute_add
 
  # Зададим операнды деления
  s/$/\ndiv::first_operand = add::result/
  x ; s/\(call_stack = [^\n]*\)/\1,rng::div_set_1/ ; x
  b copy
  :rng::div_set_1

  s/$/\ndiv::second_operand = rng::M/
  x ; s/\(call_stack = [^\n]*\)/\1,rng::div_set_2/ ; x
  b copy
  :rng::div_set_2

  # Выполним деление и получим в mod_result новое число
  x ; s/\(call_stack = [^\n]*\)/\1,rng::execute_div/ ; x
  b div
  :rng::execute_div
 
  # Скопируем новое число в текущее состояние генератора
  s/$/\nrng::current_state = div::mod_result/
  x ; s/\(call_stack = [^\n]*\)/\1,rng::result/ ; x
  b copy
  :rng::result

  b return
}

:draw
{
  # Очищаем pattern space
  s/^.*$//

  # Получаем поля
  s/$/\nfield::player/
  x ; s/\(call_stack = [^\n]*\)/\1,draw::get_field1/ ; x
  b get
  :draw::get_field1

  s/$/\nfield::suggestions/
  x ; s/\(call_stack = [^\n]*\)/\1,draw::get_field2/ ; x
  b get
  :draw::get_field2
 
  # Расставляем пробелы после каждого символа: так в терминале выглядит красивее :)
  s/\([·~HDX]\)/\1 /g

  # Не слишком изящно, но весьма наглядно: берем первые 20 символов поля из каждой строки (10 значащих и 10 пробелов),
  # удаляем их оттуда и добавляем в конец, снабжая буквенной координатой. Так делаем 10 раз.
  s/$/\n   | 0 1 2 3 4 5 6 7 8 9\t   | 0 1 2 3 4 5 6 7 8 9/
  s/$/\n---+--------------------\t---+--------------------/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 A | \1\t A | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 B | \1\t B | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 C | \1\t C | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 D | \1\t D | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 E | \1\t E | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 F | \1\t F | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 G | \1\t G | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 H | \1\t H | \3/
	s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 I | \1\t I | \3/
	s/^\([·~HDX ]\{20\}\)\n\([·~HDX ]\{20\}\)\n\(.*\)$/\3\
 J | \1\t J | \2/

  # Выводим поля
  p

  # Еще раз очищаем pattern space
  s/^.*$//

  b return
}

:convert_coordinates
{
  # Прочитаем переменную с координатой (она будет задана из инпута)
  s/$/\nconvert_coordinates::coordinates/
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::get_coordinates/ ; x
  b get
  :convert_coordinates::get_coordinates

  s/\([A-Ja-j]\) *\([0-9]\)$/\1\n\2/

  # Конвертируем цифру
  s/0$/0000000/ ; s/1$/0000001/ ; s/2$/0000010/ ; s/3$/0000011/ ; s/4$/0000100/ ; s/5$/0000101/ ; s/6$/0000110/ ; s/7$/0000111/ ; s/8$/0001000/ ; s/9$/0001001/
  s/\([^\n]*\)$/convert_coordinates::digit = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::set_digit/ ; x
  b set
  :convert_coordinates::set_digit
 
  # Конвертируем букву
  s/[Aa]$/0000000/ ; s/[Bb]$/0000001/ ; s/[Cc]$/0000010/ ; s/[Dd]$/0000011/ ; s/[Ee]$/0000100/ ; s/[Ff]$/0000101/ ; s/[Gg]$/0000110/ ; s/[Hh]$/0000111/ ; s/[Ii]$/0001000/ ; s/[Jj]$/0001001/
  s/\([^\n]*\)$/mul::first_operand = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::set_letter/ ; x
  b set
  :convert_coordinates::set_letter

  # Подготовим умножение «буквы» на 10.
  s/$/\n0001010/
  s/\([^\n]*\)$/mul::second_operand = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::set_ten/ ; x
  b set
  :convert_coordinates::set_ten

  # Выполним умножение
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::execute_mul/ ; x
  b mul
  :convert_coordinates::execute_mul

  # Подготовим сложение (letter*10 + digit)
  s/$/\nadd::first_operand = convert_coordinates::digit/
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::set_add_1/ ; x
  b copy
  :convert_coordinates::set_add_1
  
  s/$/\nadd::second_operand = mul::result/
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::set_add_2/ ; x
  b copy
  :convert_coordinates::set_add_2

  # Выполним сложение  
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::execute_add/ ; x
  b add
  :convert_coordinates::execute_add
  
  # Запишем результат
  s/$/\nconvert_coordinates::result = add::result/
  x ; s/\(call_stack = [^\n]*\)/\1,convert_coordinates::result/ ; x
  b copy
  :convert_coordinates::result

  b return
}

:get_symbol
{
  # Получаем строку
  s/$/\nget_symbol::string/
  x ; s/\(call_stack = [^\n]*\)/\1,get_symbol::get_string/ ; x
  b get
  :get_symbol::get_string

  # Получаем число в двоичном виде
  s/$/\nget_symbol::number/
  x ; s/\(call_stack = [^\n]*\)/\1,get_symbol::get_number/ ; x
  b get
  :get_symbol::get_number
 
   # Инициализируем счетчик нулем нужной битности
  s/\([01]*\)$/\1\n\1/
  :get_symbol::init_loop
  s/1\(0*\)$/0\1/
  /10*$/ b get_symbol::init_loop

  # Считаем символы, пока counter < number
  :get_symbol::count_loop
  /\([01]*\)\n\1$/ b get_symbol::end_loop
  # Удаляем первый символ строки
  s/[^\n]\([^\n]*\)\n\([01]*\)\n\([01]*\)$/\1\n\2\n\3/
  # Инлайновый инкремент счетчика: так короче, чем использовать add
  /\n0*$/ {s/\(0*\)0$/\11/ ; b get_symbol::count_loop; }
  :get_symbol::inc_loop ; s/1\(_*\)$/_\1/ ; /1_*$/ b get_symbol::inc_loop 
  s/0\(_*\)$/1\1/
  :get_symbol::inc_reverseloop ; s/_\(_*\)$/0\1/ ; /_$/ b get_symbol::inc_reverseloop;

  b get_symbol::count_loop
  :get_symbol::end_loop

  # Чистим артефакты, записываем результат
  s/\([^\n]\)[^\n]*\n[01]*\n[01]*$/get_symbol::result = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,get_symbol::result/ ; x
  b set
  :get_symbol::result
  b return
}

:set_symbol
{
  # Получим строку, поставим перед ней пробел
  s/$/\nset_symbol::string/
  x ; s/\(call_stack = [^\n]*\)/\1,set_symbol::get_string/ ; x
  b get
  :set_symbol::get_string
  s/\([^\n]*\)$/ \1/

  # Получим символ
  s/$/\nset_symbol::symbol/
  x ; s/\(call_stack = [^\n]*\)/\1,set_symbol::get_symbol/ ; x
  b get
  :set_symbol::get_symbol
   
  # Получчим число в двоичном виде
  s/$/\nset_symbol::number/
  x ; s/\(call_stack = [^\n]*\)/\1,set_symbol::get_number/ ; x
  b get
  :set_symbol::get_number
 
  # Инициализируем счетчик нулем нужной битности
  s/\([01]*\)$/\1\n\1/
  :set_symbol::init_loop
  s/1\(0*\)$/0\1/
  /10*$/ b set_symbol::init_loop

  # Считаем символы, пока counter < number
  :set_symbol::count_loop
  /\([01]*\)\n\1$/ b set_symbol::end_loop
  # Перемещаем очередной символ за пробел
  s/\([^\n ]*\) \([^\n]\)\([^\n]*\)\n\([^\n]\)\n\([01]*\)\n\([01]*\)$/\1\2 \3\n\4\n\5\n\6/
  # Инлайновый инкремент
  /\n0*$/ {s/\(0*\)0$/\11/ ; b set_symbol::count_loop; }
  :set_symbol::inc_loop ; s/1\(_*\)$/_\1/ ; /1_*$/ b set_symbol::inc_loop 
  s/0\(_*\)$/1\1/
  :set_symbol::inc_reverseloop ; s/_\(_*\)$/0\1/ ; /_$/ b set_symbol::inc_reverseloop;

  b set_symbol::count_loop
  :set_symbol::end_loop

  # Заменим символ и почистим артефакты  
  s/\([^\n ]*\) [^\n]\([^\n]*\)\n\([^\n]\)\n[01]*\n[01]*$/\1\3\2/

  # Запишем в результат новую строку 
  s/\([^\n]*\)$/set_symbol::result = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,set_symbol::result/ ; x
  b set
  :set_symbol::result
  b return
}

:sink_computer_ship
{
  # Получим подбитую клетку
  s/$/\nconvert_coordinates::result/
  x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::get_ship_cell/ ; x
  b get
  :sink_computer_ship::get_ship_cell

  # Получим все корабли противника
  s/$/\nfield::computer_ships/
  x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::get_all_ships/ ; x
  b get
  :sink_computer_ship::get_all_ships

  # Оставим координаты только нужного корабля
  s/\([^\n]*\)$/ \1/
  s/\([01]*\)\n[^\n]* \([01,]*\)\1\([01,]*\)[^\n]*$/\2\1\3/

  # Выставим символ затопленного корабля
  s/\([^\n]*\)$/\1\nset_symbol::symbol = X/
   x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::set_sink_symbol/ ; x
   b set
   :sink_computer_ship::set_sink_symbol

  :sink_computer_ship::sink_loop
  /[01]$/ {
    # Выставим номер клетки для затопления
    s/\([01]*\)$/\nset_symbol::number = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::set_cell_number/ ; x
    b set
    :sink_computer_ship::set_cell_number
  
    # Подготовим поле противника для изменения
    s/$/\nset_symbol::string = field::computer/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::set_enemy_string/ ; x
    b copy
    :sink_computer_ship::set_enemy_string

    # Заменим символ на поле противника
     x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::change_enemy_field/ ; x
     b set_symbol 
    :sink_computer_ship::change_enemy_field

    s/$/\nfield::computer = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::save_enemy_field/ ; x
    b copy
    :sink_computer_ship::save_enemy_field
    
    # Подготовим поле саджестов для изменения
    s/$/\nset_symbol::string = field::suggestions/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::set_suggestions_string/ ; x
    b copy
    :sink_computer_ship::set_suggestions_string

    # Заменим символ на поле саджестов
     x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::change_suggestions_field/ ; x
     b set_symbol 
    :sink_computer_ship::change_suggestions_field

    s/$/\nfield::suggestions = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_computer_ship::save_suggestions_field/ ; x
    b copy
    :sink_computer_ship::save_suggestions_field
    s/[01]*\n[^\n]$//
    s/,$//
    b sink_computer_ship::sink_loop
  }

  b return
}

:analyze_ship_state
{
  # Инициаллизируем результат
  s/$/\nanalyze_ship_state::result = /
  x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::init/ ; x
  b set
  :analyze_ship_state::init
  
  s/$/\nanalyze_ship_state::coordinate/
  x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::get_ship_cell/ ; x
  b get
  :analyze_ship_state::get_ship_cell

  s/$/\nanalyze_ship_state::ships/
  x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::get_all_ships/ ; x
  b get
  :analyze_ship_state::get_all_ships

  s/$/\nget_symbol::string = analyze_ship_state::field/
  x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::set_enemy_string/ ; x
  b copy
  :analyze_ship_state::set_enemy_string

  # Оставим только нужный корабль
  s/\([^\n]*\)$/ \1/
  s/\([01]*\)\n[^\n]* \([01,]*\)\1\([01,]*\)[^\n]*$/\2\1\3/
  
  :analyze_ship_state::cell_loop
  /[01]$/ {
    # Зададим номер клетки
    s/\([01]*\)$/\nget_symbol::number = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::set_enemy_cell/ ; x
    b set
    :analyze_ship_state::set_enemy_cell

    x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::calculate_enemy_cell/ ; x
    b get_symbol 
    :analyze_ship_state::calculate_enemy_cell

    s/$/\nget_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::get_enemy_cell/ ; x
    b get
    :analyze_ship_state::get_enemy_cell
    
    # Если наткнулись на здоровую клетку, то корабль просто подбит
    /H$/ b analyze_ship_state::not_sunk

    # Удалим проанализированную клетку
    s/[01]*\n[^\n]$//
    s/,$//
    b analyze_ship_state::cell_loop
  }

  s/D*\n*$/analyze_ship_state::result = sunk/
  x ; s/\(call_stack = [^\n]*\)/\1,analyze_ship_state::sunk/ ; x
  b set
  :analyze_ship_state::sunk

  :analyze_ship_state::not_sunk
  b return
}

:check_win
{
  s/$/\nfield::computer/
  x ; s/\(call_stack = [^\n]*\)/\1,check_win::get_enemy_field/ ; x
  b get
  :check_win::get_enemy_field
  
  # Если на поле только вода и затопленные корабли, игрок побеждает
  /\n[~X]*$/ {
    x ; s/\(call_stack = [^\n]*\)/\1,check_win::draw/ ; x
    b draw
    :check_win::draw
    s/^.*$/\nCongratulations, you've won!/
    p
    q
  }
  s/\n*[~HDX]*//
  b return 
}

:mark_diagonal_cross
{
  # Выставим символ воды
  s/\([^\n]*\)$/\1\nset_symbol::symbol = ~/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::set_water_symbol/ ; x
  b set
  :mark_diagonal_cross::set_water_symbol

  # Надо убедиться, что мы не выходим за пределы поля.
  # Это проще делать, выполнив деление на 10 и получив отдельные координаты по X и Y
  s/$/\ndiv::first_operand = mark::coordinates/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::div_set_1/ ; x
  b copy
  :mark_diagonal_cross::div_set_1

  s/$/\ndiv::second_operand = 0001010/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::div_set_2/ ; x
  b set
  :mark_diagonal_cross::div_set_2

  # Выполним деление
  x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::execute_div/ ; x
  b div
  :mark_diagonal_cross::execute_div

  # Получим результаты деления (координаты)
  s/$/\ndiv::div_result/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::get_y_coordinate/ ; x
  b get
  :mark_diagonal_cross::get_y_coordinate

  s/$/\ndiv::mod_result/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::get_x_coordinate/ ; x
  b get
  :mark_diagonal_cross::get_x_coordinate
  
  # Заведем слагаемые для перехода к соседям по диагонали: 9, 11, -9, -11
  s/$/\n,1110101,1110111,0001001,0001011/
  :mark_diagonal_cross::loop
  /[01]$/ {
    # Проверка северной границы: если y-координата равна 0, пропускаем прибавление -9 и -11
    /0000000\n[01]*\n[01,]*,1[01]*$/ b mark_diagonal_cross::cross_cell_handled
    # Проверка южной границы: если y-координата равна 9, пропускаем прибавление 9 и 11
    /0001001\n[01]*\n[01,]*,0[01]*$/ b mark_diagonal_cross::cross_cell_handled
    # Проверка западной границы: если x-координата равна 0, пропускаем прибавление 9 и -11
    /0000000\n[01,]*,[01]*01$/ b mark_diagonal_cross::cross_cell_handled
    # Проверка восточной границы: если x-координата равна 9, пропускаем прибавление 11 и -9
    /0001001\n[01,]*,[01]*11$/ b mark_diagonal_cross::cross_cell_handled

    # Задаем первое слагаемое — подбитая клетка
    s/$/\nadd::first_operand = mark::coordinates/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::set_add_1/ ; x
    b copy
    :mark_diagonal_cross::set_add_1

    # Задаем второе слагаемое: 9, 11, -9 или -11
    s/\([01]*\)$/\1\nadd::second_operand = \1/
     x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::set_add_2/ ; x
     b set
     :mark_diagonal_cross::set_add_2

    # Выполним сложение
    x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::calculate_cross_cell/ ; x
    b add
    :mark_diagonal_cross::calculate_cross_cell

    # Зададим номер клетки
    s/\([^\n]*\)$/\1\nset_symbol::number = add::result/
     x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::set_mark_cell/ ; x
     b copy
     :mark_diagonal_cross::set_mark_cell

    # Подготовим поле саджестов для изменений
    s/$/\nset_symbol::string = mark::field/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::set_suggestions_string/ ; x
    b copy
    :mark_diagonal_cross::set_suggestions_string

    # Обновим поле саджестов
    x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::perform_field_change/ ; x
    b set_symbol 
    :mark_diagonal_cross::perform_field_change

    s/$/\nmark::field = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_diagonal_cross::change_suggestions_field/ ; x
    b copy
    :mark_diagonal_cross::change_suggestions_field

    :mark_diagonal_cross::cross_cell_handled
    # Clean the handled cell
    s/,[01]*$//
    b mark_diagonal_cross::loop
  }

  # Чистим артефакты
  s/\n[01]*\n[01]*\n$//
  b return
}

:mark_circle
{
  # Получаем клетки корабля компьютера
  s/$/\nmark::ship/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_circle::get_ship_cells/ ; x
  b get
  :mark_circle::get_ship_cells

  :mark_circle::loop
  /[01]$/ {
    s/\([01]*\)$/\1\nmark_common_cross::cell = \1/
     x ; s/\(call_stack = [^\n]*\)/\1,mark_circle::set_ship_cell/ ; x
     b set
     :mark_circle::set_ship_cell

     x ; s/\(call_stack = [^\n]*\)/\1,mark_circle::mark_common_cross/ ; x
     b mark_common_cross
     :mark_circle::mark_common_cross
    s/,[01]*$//
    b mark_circle::loop
  }
  b return
}

:mark_common_cross
{
  # Выставим символ воды
  s/\([^\n]*\)$/\1\nset_symbol::symbol = ~/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::set_water_symbol/ ; x
  b set
  :mark_common_cross::set_water_symbol

  # Надо убедиться, что мы не выходим за пределы поля.
  # Это проще делать, выполнив деление на 10 и получив отдельные координаты по X и Y
  s/$/\ndiv::first_operand = mark_common_cross::cell/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::div_set_1/ ; x
  b copy
  :mark_common_cross::div_set_1

  s/$/\ndiv::second_operand = 0001010/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::div_set_2/ ; x
  b set
  :mark_common_cross::div_set_2

  # Выполняем деление и получаем результаты
  x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::execute_div/ ; x
  b div
  :mark_common_cross::execute_div

  s/$/\ndiv::div_result/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::get_y_coordinate/ ; x
  b get
  :mark_common_cross::get_y_coordinate

  s/$/\ndiv::mod_result/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::get_x_coordinate/ ; x
  b get
  :mark_common_cross::get_x_coordinate

  # Получаем клетки корабля компьютера
  s/$/\nmark::ship/
  x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::get_ship_cells/ ; x
  b get
  :mark_common_cross::get_ship_cells

  # Заведем слагаемые для доступа к соседям по ребру: 1, -1, 10, -10
  s/$/\n,0001010,1110110,0000001,1111111/
  :mark_common_cross::loop
  /[01]$/ {
    # Север: не вычитаем 10, если y-координата равна 0
    /0000000\n[01]*\n[01,]*\n[01,]*,1110110$/ b mark_common_cross::cross_cell_handled
    # Юг: не прибавляем 10, если y-координата равна 9
    /0001001\n[01]*\n[01,]*\n[01,]*,0001010$/ b mark_common_cross::cross_cell_handled
    # Запад: не вычитаем 1, если x-координата равна 0
    /0000000\n[01,]*\n[01,]*,1111111$/ b mark_common_cross::cross_cell_handled
    # Восток: не прибавляем 1, если x-координата равна 9
    /0001001\n[01,]*\n[01,]*,0000001$/ b mark_common_cross::cross_cell_handled

    # Первое слагаемое — подбитая клетка
    s/$/\nadd::first_operand = mark_common_cross::cell/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::set_add_1/ ; x
    b copy
    :mark_common_cross::set_add_1

    # Второе слагаемое: 1, 10, -1 или -10
    s/\([01]*\)$/\1\nadd::second_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::set_add_2/ ; x
    b set
    :mark_common_cross::set_add_2

    # Выполняем сложение
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::calculate_cross_cell/ ; x
    b add
    :mark_common_cross::calculate_cross_cell

    # Дополнительная проверка, что клетка результата реально пустая (в ней может быть затопленный корабль)
    s/$/\nadd::result/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::set_cell_to_check/ ; x
    b get
    :mark_common_cross::set_cell_to_check

    s/\([01,]*\)\n\([01,]*\)\n\([01]*\)$/\1\n\2\n\3 \1/
    /\n\([01]*\) [01,]*\1[01,]*$/ {s/\n[01, ]*$// ; b mark_common_cross::cross_cell_handled ; }

    # Чистим артефакт проверки
    s/\n[01, ]*$//
  
    # Задаем номер клетки
    s/\([^\n]*\)$/\1\nset_symbol::number = add::result/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::set_mark_cell/ ; x
    b copy
    :mark_common_cross::set_mark_cell

    # Готовим поле саджестов к обновлению
    s/$/\nset_symbol::string = mark::field/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::set_suggestions_string/ ; x
    b copy
    :mark_common_cross::set_suggestions_string

    # Обновляем поле саджестов
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::perform_field_change/ ; x
    b set_symbol 
    :mark_common_cross::perform_field_change

    s/$/\nmark::field = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,mark_common_cross::change_suggestions_field/ ; x
    b copy
    :mark_common_cross::change_suggestions_field

    :mark_common_cross::cross_cell_handled
    # Clean the handled cell
    s/,[01]*$//
    b mark_common_cross::loop
  }
  s/\n[01]*\n[01]*\n[01,]*\n*$//
  b return
}

:player_move {
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::draw/ ; x
  b draw
  :player_move::draw
  # Input coordinates
  n
  # Анализ хода
  /^[A-Ja-j] *[0-9]$/ { b player_move::valid_move}
  s/$/\nlast_action_log = Invalid move, type a single letter and a single digit like A0 or H5./
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::invalid_move/ ; x
  b set
  :player_move::invalid_move
  b player_move

  :player_move::valid_move
  # Задаем координаты для конвертации
  s/^\([^\n]*\)$/convert_coordinates::coordinates = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_coordinates/ ; x
  b set
  :player_move::set_coordinates
  
  # Конвертируем координаты
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::convert_coordinates/ ; x
  b convert_coordinates
  :player_move::convert_coordinates

  # Задаем переменные для анализа клетки поля саджестов
  s/$/\nget_symbol::string = field::suggestions/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_suggestion_string/ ; x
  b copy
  :player_move::set_suggestion_string
    
  s/$/\nget_symbol::number = convert_coordinates::result/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_number/ ; x
  b copy
  :player_move::set_number
  
  # Получаем клетку с поля саджестов
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::get_suggestion_cell/ ; x
  b get_symbol 
  :player_move::get_suggestion_cell

  # Анализировать клетку поля саджестов будем в основном буфере
  s/^.*$/get_symbol::result/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::put_suggestion_cell/ ; x
  b get
  :player_move::put_suggestion_cell
  
  # Если клетка уже проверена, попробуем еще раз
  /[~DX]/ {
    s/$/\nlast_action_log = This cell has already been checked, try another one./
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::already_checked/ ; x
    b set
    :player_move::already_checked
    b player_move
  }

  # Зададим поле для получения символа
  s/$/\nget_symbol::string = field::computer/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_enemy_string/ ; x
  b copy
  :player_move::set_enemy_string

  # Получим нужный символ с поля противника
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::get_enemy_cell/ ; x
  b get_symbol 
  :player_move::get_enemy_cell

  # Анализировать полученную клетку будем в основном буфере
  s/^.*$/get_symbol::result/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::put_enemy_cell/ ; x
  b get
  :player_move::put_enemy_cell

  # При попадании сперва пометим клетку как поврежденную
  s/H/D/

  # Подготовим обновление поля саджестов
  s/\([^\n]*\)$/\1\nset_symbol::symbol = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_missed_symbol/ ; x
  b set
  :player_move::set_missed_symbol
  
  s/$/\nset_symbol::number = convert_coordinates::result/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_missed_number/ ; x
  b copy
  :player_move::set_missed_number

  s/$/\nset_symbol::string = field::suggestions/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_missed_string/ ; x
  b copy
  :player_move::set_missed_string

  # Обновим поле саджестов
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::change_missed_string/ ; x
  b set_symbol 
  :player_move::change_missed_string

  s/$/\nfield::suggestions = set_symbol::result/
  x ; s/\(call_stack = [^\n]*\)/\1,player_move::perform_missed/ ; x
  b copy
  :player_move::perform_missed

  # Обработка промаха
  /~$/ {
    s/$/\nlast_action_log = You've missed! Now it's my turn./
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::log_miss/ ; x
    b set
    :player_move::log_miss
    b player_move::end_move
  }
  
  # Обработка попадания
  /D$/ {
    s/$/\nlast_action_log = Ouch! My ship is damaged!/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::log_hit/ ; x
    b set
    :player_move::log_hit
     
    s/\([^\n]*\)$/\1\nset_symbol::symbol = D/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_hit_symbol/ ; x
    b set
    :player_move::set_hit_symbol
  
    s/$/\nset_symbol::string = field::computer/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_hit_string/ ; x
    b copy
    :player_move::set_hit_string

    # Обновляем поле компьютера
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::change_hit_string/ ; x
    b set_symbol 
    :player_move::change_hit_string

    s/$/\nfield::computer = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::perform_hit/ ; x
    b copy
    :player_move::perform_hit

    # Проводим анализ состояния корабля
    s/$/\nanalyze_ship_state::coordinate = convert_coordinates::result/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::prepare_analysis_coordinate/ ; x
    b copy
    :player_move::prepare_analysis_coordinate
    
    s/$/\nanalyze_ship_state::ships = field::computer_ships/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::prepare_analysis_ships/ ; x
    b copy
    :player_move::prepare_analysis_ships
       
    s/$/\nanalyze_ship_state::field = field::computer/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::prepare_analysis_field/ ; x
    b copy
    :player_move::prepare_analysis_field

    x ; s/\(call_stack = [^\n]*\)/\1,player_move::analysis/ ; x
    b analyze_ship_state
    :player_move::analysis

    s/$/\nanalyze_ship_state::result/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::get_analysis_result/ ; x
    b get
    :player_move::get_analysis_result
  
    # Подготовим переменные для маркировки: поле и номер клетки
    s/$/\nmark::coordinates = convert_coordinates::result/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::prepare_mark_coordinates/ ; x
    b copy
    :player_move::prepare_mark_coordinates

    s/$/\nmark::field = field::suggestions/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::prepare_mark_field/ ; x
    b copy
    :player_move::prepare_mark_field

    # Маркируем соседей по диагонали как пустые клетки 
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::mark_diagonal_cross/ ; x
    b mark_diagonal_cross
    :player_move::mark_diagonal_cross
    
    s/$/\nfield::suggestions = mark::field/
    x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_diagonal_cross/ ; x
    b copy
    :player_move::set_diagonal_cross
  
    /sunk$/ {
      s/\n*sunk$//
  
      # Обновляем поле саджестов
      s/$/\nmark::field = field::suggestions/
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::update_before_sink/ ; x
      b copy
      :player_move::update_before_sink
    
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::sink_ship/ ; x
      b sink_computer_ship
      :player_move::sink_ship
      
      # Получаем координаты корабля
      s/$/\nmark::coordinates/
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::get_hit_cell/ ; x
      b get
      :player_move::get_hit_cell
      
      s/$/\nfield::computer_ships/
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::get_ship_list/ ; x
      b get
      :player_move::get_ship_list
    
      s/$/\nmark::field = field::suggestions/
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::prepare_mark_field_2/ ; x
      b copy
      :player_move::prepare_mark_field_2
      
      s/\([^\n]*\)$/ \1/
      s/\([01]*\)\n[^\n]* \([01,]*\)\1\([01,]*\)[^\n]*$/,\2\1\3/
      s/\([01,]*\)$/mark::ship = \1/
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_ship_cells/ ; x
      b set
      :player_move::set_ship_cells

      x ; s/\(call_stack = [^\n]*\)/\1,player_move::mark_circle/ ; x
      b mark_circle  
      :player_move::mark_circle
    
      # Обновляем поле саджестов
      s/$/\nfield::suggestions = mark::field/
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::set_suggestions_field/ ; x
      b copy
      :player_move::set_suggestions_field
     
      s/$/\nlast_action_log = OK, you've managed to sink my ship. Happy?/
      x ; s/\(call_stack = [^\n]*\)/\1,player_move::log_sink/ ; x
      b set
      :player_move::log_sink
    }
    

    x ; s/\(call_stack = [^\n]*\)/\1,player_move::check_win/ ; x
    b check_win
    :player_move::check_win

    # Make yet another move
    b player_move
  }
  
  :player_move::end_move
  b computer_move  # Это пока не реализовано, но очень скоро будет
}

:generate_computer_move {
  # Генерируем случайное число
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::random/ ; x
  b rng
  :generate_computer_move::random
  
  # Считаем лимит: 2N + kL
  s/$/\nfield::player/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::get_player_field/ ; x
  b get
  :generate_computer_move::get_player_field

  # Инициализируем счетчики для N и k
  # Все будет 32-битным, т.к. придется работать еще и со случайными числами
  s/\n\([^\n]*\)$/00000000000000000000000000000000\n00000000000000000000000000000000\n\1/
  :generate_computer_move::calculate_cells_loop
  /H$/ {
    # Инлайновый инкремент для k
    :generate_computer_move::inc_healthy_count_loop
    /\n0*\n[·~HDX]*$/ {s/\(0*\)0\n\([^\n]*\)$/\11\n\2/ ; b generate_computer_move::inc_healthy_reverseloop; }
    :generate_computer_move::inc_healthy_loop ; s/1\(_*\)\n\([^\n]*\)$/_\1\n\2/ ; /1_*\n[^\n]*$/ b generate_computer_move::inc_healthy_loop
    s/0\(_*\)\n\([^\n]*\)$/1\1\n\2/
    :generate_computer_move::inc_healthy_reverseloop ; s/_\(_*\)\n\([^\n]*\)$/0\1\n\2/ ; /_\n[^\n]*$/ b generate_computer_move::inc_healthy_reverseloop ;
  }
  /[·H]$/ {
    # Инлайновый инкремент для N
    :generate_computer_move::inc_total_count_loop
    /^0*\n[01]*\n[^\n]*$/ {s/\(0*\)0\n\([01]*\)\n\([^\n]*\).$/\11\n\2\n\3/ ; b generate_computer_move::inc_total_reverseloop; }
    :generate_computer_move::inc_total_loop ; s/1\(_*\)\n\([01]*\)\n\([^\n]*\)$/_\1\n\2\n\3/ ; /1_*\n[01]*\n[^\n]*$/ b generate_computer_move::inc_total_loop
    s/0\(_*\)\n\([01]*\)\n\([^\n]*\)$/1\1\n\2\n\3/
    :generate_computer_move::inc_total_reverseloop ; s/_\(_*\)\n\([01]*\)\n\([^\n]*\)$/0\1\n\2\n\3/ ; /_\n[01]*\n[^\n]*$/ b generate_computer_move::inc_total_reverseloop ;
  }
  # Удаляем последний символ
  s/.$//
  /[^\n]$/ b generate_computer_move::calculate_cells_loop
  s/\n$//
  
  # Готовим первое слагаемое числителя: 2*k
  s/\([01]\)\([01]*\)$/\1\2\ngenerate_computer_move::2_healthy_cells = \20/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::save_2_healthy_cells/ ; x
  b set
  :generate_computer_move::save_2_healthy_cells
  
  # Готовим первое слагаемое знаменателя: 2*N
  s/[01]\([01]*\)\n\([01]*\)$/\2\ngenerate_computer_move::total_cells_factor = \10/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::save_total_cells_factor/ ; x
  b set
  :generate_computer_move::save_total_cells_factor
  
  # Готовим второе слагаемое: k*L
  s/\([01]*\)$/mul::first_operand = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_healthy_cells_factor_1/ ; x
  b set
  :generate_computer_move::prepare_healthy_cells_factor_1

  s/$/\nmul::second_operand = luck/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_healthy_cells_factor_2/ ; x
  b copy
  :generate_computer_move::prepare_healthy_cells_factor_2

  # Выполняем умножение
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::perform_mul/ ; x
  b mul
  :generate_computer_move::perform_mul

  s/$/\ngenerate_computer_move::healthy_cells_factor = mul::result/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::save_healthy_cells_factor/ ; x
  b copy
  :generate_computer_move::save_healthy_cells_factor
  
  # Готовим сложение
  s/$/\nadd::first_operand = mul::result/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_add_1/ ; x
  b copy
  :generate_computer_move::prepare_add_1
  
  s/$/\nadd::second_operand = generate_computer_move::total_cells_factor/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_add_2/ ; x
  b copy
  :generate_computer_move::prepare_add_2

  # Выполняем сложение
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::perform_add/ ; x
  b add
  :generate_computer_move::perform_add

  # Делим случайное число на посчитанный лимит
  s/$/\ndiv::first_operand = rng::current_state/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_random_limitation_1/ ; x
  b copy
  :generate_computer_move::prepare_random_limitation_1

  s/$/\ndiv::second_operand = add::result/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_random_limitation_2/ ; x
  b copy
  :generate_computer_move::prepare_random_limitation_2

  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::perform_random_limitation/ ; x
  b div
  :generate_computer_move::perform_random_limitation

  # Посчитаем границу, определяющую промах или попадание
  s/$/\nadd::first_operand = generate_computer_move::healthy_cells_factor/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_set_partition_limit_1/ ; x
  b copy
  :generate_computer_move::prepare_set_partition_limit_1
  
  s/$/\nadd::second_operand = generate_computer_move::2_healthy_cells/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_set_partition_limit_2/ ; x
  b copy
  :generate_computer_move::prepare_set_partition_limit_2

  # Выполним сложение
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::calculate_set_partition_limit/ ; x
  b add
  :generate_computer_move::calculate_set_partition_limit

  # Сравним случайное число с границей промаха/попадания
  s/$/\ndiv::mod_result/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::get_limited_random/ ; x
  b get
  :generate_computer_move::get_limited_random

  s/$/\nadd::result/
  x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::get_set_partition_limit/ ; x
  b get
  :generate_computer_move::get_set_partition_limit

  # Процедура сравнения
  /\([01]*\)\n\1$/ b generate_computer_move::miss_result
  s/\([01]*\)\n\([01]*\)$/ \1\n \2/
  :generate_computer_move::compare_loop
    s/\([01]*\) \([01]\)\([01]*\)\n\([01]*\) \([01]\)\([01]*\)$/\1\2 \3\n\4\5 \6/
    /0 [01]*\n[01]*1 [01]*$/ b generate_computer_move::hit_result
    /1 [01]*\n[01]*0 [01]*$/ b generate_computer_move::miss_result
    b generate_computer_move::compare_loop

  :generate_computer_move::hit_result {
    s/\([01]*\) \([01]*\)\n[01 ]*$/\1\2/
    
    # Делим число на 2+L.
    s/$/\nluck/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::get_luck/ ; x
    b get
    :generate_computer_move::get_luck

    s/\([01]*\)$/add::first_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_divisor_1/ ; x
    b set
    :generate_computer_move::prepare_divisor_1
    
    # 2
    s/$/\nadd::second_operand = 00000000000000000000000000000010/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_divisor_2/ ; x
    b set
    :generate_computer_move::prepare_divisor_2

    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::build_divisor/ ; x
    b add
    :generate_computer_move::build_divisor
  
    # Еще одно деление
    s/\([01]*\)$/div::first_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::set_hit_dividend/ ; x
    b set
    :generate_computer_move::set_hit_dividend

    s/\([01]*\)$/div::second_operand = add::result/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::set_hit_divisor/ ; x
    b copy
    :generate_computer_move::set_hit_divisor

    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::perform_hit_div/ ; x
    b div
    :generate_computer_move::perform_hit_div
  
    # Запишем результат: H и номер клетки с кораблем
    s/$/\ngenerate_computer_move::cell_type = H/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::set_hit_type/ ; x
    b set
    :generate_computer_move::set_hit_type
    
    s/$/\ngenerate_computer_move::cell_number = div::div_result/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::set_hit_number/ ; x
    b copy
    :generate_computer_move::set_hit_number
    
    b return
  }
  
  :generate_computer_move::miss_result {
    s/\([01]*\) \([01]*\)\n\([01]*\) \([01]*\)$/\1\2\n\3\4/

    # Вычитаем 2*healthy_cells + healthy_cells*luck
    s/\([01]*\)$/add::second_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_miss_sub_1/ ; x
    b set
    :generate_computer_move::prepare_miss_sub_1
    
    # Из нашего случайного числа
    s/\([01]*\)$/add::first_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::prepare_miss_sub_2/ ; x
    b set
    :generate_computer_move::prepare_miss_sub_2

    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::build_dividend/ ; x
    b sub
    :generate_computer_move::build_dividend
      
    s/$/\nadd::result/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::get_miss_cell_number/ ; x
    b get
    :generate_computer_move::get_miss_cell_number

    # Пишем результат: · и номер пустой клетки
    s/\([01]*\)[01]$/\ngenerate_computer_move::cell_number = 0\1/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::set_miss_number/ ; x
    b set
    :generate_computer_move::set_miss_number
    
    s/$/\ngenerate_computer_move::cell_type = ·/
    x ; s/\(call_stack = [^\n]*\)/\1,generate_computer_move::set_miss_type/ ; x
    b set
    :generate_computer_move::set_miss_type

    b return
  }  
}

:reverse_convert_coordinates {
  s/$/\ngenerate_computer_move::cell_type/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::get_cell_type/ ; x
  b get
  :reverse_convert_coordinates::get_cell_type
  
  s/$/\ngenerate_computer_move::cell_number/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::get_cell_number/ ; x
  b get
  :reverse_convert_coordinates::get_cell_number

  # Подстрижем номер клетки: нам нужно не больше 7 бит
  s/[01]*\([01]\{7\}\)$/\1/
  # Инициализируем два счетчика
  s/$/\n0000000\n0000000/

  s/$/\nfield::player/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::get_player_field/ ; x
  b get
  :reverse_convert_coordinates::get_player_field

  :reverse_convert_coordinates::cell_count_loop
    # Останавливаемся, когда первый счетчик достиг лимита
    # И ПРИ ЭТОМ
    # мы рассматриваем клетку нужного типа
    /\([·~HDX]\)\n\([01]*\)\n\2\n[01]*\n\1[·~HDX]*$/ b reverse_convert_coordinates::end_loop

    # Инкрементим первый счетчик, если перед нами клетка нужного типа
    /\([·~HDX]\)\n[01]*\n[01]*\n[01]*\n\1[·~HDX]*$/ {
      /\n0*\n[01]*\n[·~HDX]*$/ {s/\(0*\)0\n\([01]*\)\n\([·~HDX]*\)$/\11\n\2\n\3/ ; b reverse_convert_coordinates::first_count_endloop; }
      :reverse_convert_coordinates::first_inc_loop ; s/1\(_*\)\n\([01]*\)\n\([·~HDX]*\)$/_\1\n\2\n\3/ ; /1_*\n[01]*\n[·~HDX]*$/ b reverse_convert_coordinates::first_inc_loop
      s/0\(_*\)\n\([01]*\)\n\([·~HDX]*\)$/1\1\n\2\n\3/
      :reverse_convert_coordinates::first_inc_reverseloop ; s/_\(_*\)\n\([01]*\)\n\([·~HDX]*\)$/0\1\n\2\n\3/ ; /_\n[01]*\n[·~HDX]*$/ b reverse_convert_coordinates::first_inc_reverseloop;
      :reverse_convert_coordinates::first_count_endloop
    }

    # Безусловный инкремент второго счетчика
    /\n0*\n[·~HDX]*$/ {s/\(0*\)0\n\([·~HDX]*\)$/\11\n\2/ ; b reverse_convert_coordinates::second_count_endloop; }
    :reverse_convert_coordinates::second_inc_loop ; s/1\(_*\)\n\([·~HDX]*\)$/_\1\n\2/ ; /1_*\n[·~HDX]*$/ b reverse_convert_coordinates::second_inc_loop
    s/0\(_*\)\n\([·~HDX]*\)$/1\1\n\2/
    :reverse_convert_coordinates::second_inc_reverseloop ; s/_\(_*\)\n\([·~HDX]*\)$/0\1\n\2/ ; /_\n[·~HDX]*$/ b reverse_convert_coordinates::second_inc_reverseloop;
    :reverse_convert_coordinates::second_count_endloop
     
     # Удаляем очередной символ поля
    s/[·~HDX]\([·~HDX]*\)$/\1/
    b reverse_convert_coordinates::cell_count_loop
  :reverse_convert_coordinates::end_loop

  # Чистим артефакты, оставляем только номер клетки
  s/[·~HDX]\n[01]*\n[01]*\n\([01]*\)\n[·~HDX]*$/\1/

  # Сохраним итоговый номер клетки
  s/\([01]*\)$/\1\nreverse_convert_coordinates::result_number = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::save_result_number/ ; x
  b set
  :reverse_convert_coordinates::save_result_number
  
  # Поделим число на 10
  s/\([01]*\)$/div::first_operand = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::prepare_coordinate_div_1/ ; x
  b set
  :reverse_convert_coordinates::prepare_coordinate_div_1

  s/\([01]*\)$/div::second_operand = 0001010/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::prepare_coordinate_div_2/ ; x
  b copy
  :reverse_convert_coordinates::prepare_coordinate_div_2

  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::perform_coordinate_div/ ; x
  b div
  :reverse_convert_coordinates::perform_coordinate_div

  s/$/\ndiv::div_result/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::get_y_coordinate/ ; x
  b get
  :reverse_convert_coordinates::get_y_coordinate
  
  s/$/\ndiv::mod_result/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::get_x_coordinate/ ; x
  b get
  :reverse_convert_coordinates::get_x_coordinate

  # Конвертируем букву
  s/0000000\n\([01]*\)$/A\n\1/ ; s/0000001\n\([01]*\)$/B\n\1/ ; s/0000010\n\([01]*\)$/C\n\1/ ; s/0000011\n\([01]*\)$/D\n\1/ ; s/0000100\n\([01]*\)$/E\n\1/ ; s/0000101\n\([01]*\)$/F\n\1/ ; s/0000110\n\([01]*\)$/G\n\1/ ; s/0000111\n\([01]*\)$/H\n\1/ ; s/0001000\n\([01]*\)$/I\n\1/ ; s/0001001\n\([01]*\)$/J\n\1/ 
  
  # Конвертируем цифру
  s/\n0000000$/0/ ; s/\n0000001$/1/ ; s/\n0000010$/2/ ; s/\n0000011$/3/ ; s/\n0000100$/4/ ; s/\n0000101$/5/ ; s/\n0000110$/6/ ; s/\n0000111$/7/ ; s/\n0001000$/8/ ; s/\n0001001$/9/

  # Сохраним человекочитаемые координаты
  s/\([A-J][0-9]\)$/reverse_convert_coordinates::result_string = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,reverse_convert_coordinates::save_result_string/ ; x
  b set
  :reverse_convert_coordinates::save_result_string
  
  b return
}

:sink_player_ship
{
  # Получим координату попадания
  s/$/\nreverse_convert_coordinates::result_number/
  x ; s/\(call_stack = [^\n]*\)/\1,sink_player_ship::get_ship_cell/ ; x
  b get
  :sink_player_ship::get_ship_cell

  # Получим корабли игрока
  s/$/\nfield::player_ships/
  x ; s/\(call_stack = [^\n]*\)/\1,sink_player_ship::get_all_ships/ ; x
  b get
  :sink_player_ship::get_all_ships

  # Оставим только нужный корабль
  s/\([^\n]*\)$/ \1/
  s/\([01]*\)\n[^\n]* \([01,]*\)\1\([01,]*\)[^\n]*$/\2\1\3/

  # Выставим символ затопленного корабля (X)
  s/\([^\n]*\)$/\1\nset_symbol::symbol = X/
   x ; s/\(call_stack = [^\n]*\)/\1,sink_player_ship::set_sink_symbol/ ; x
   b set
   :sink_player_ship::set_sink_symbol

  :sink_player_ship::sink_loop
  /[01]$/ {
    # Зададим номер клетки для затопления
    s/\([01]*\)$/\nset_symbol::number = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_player_ship::set_cell_number/ ; x
    b set
    :sink_player_ship::set_cell_number
  
    # Подготовим поле игрока для обновления
    s/$/\nset_symbol::string = field::player/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_player_ship::set_enemy_string/ ; x
    b copy
    :sink_player_ship::set_enemy_string

    # Обновим поле игрока
     x ; s/\(call_stack = [^\n]*\)/\1,sink_player_ship::change_enemy_field/ ; x
     b set_symbol 
    :sink_player_ship::change_enemy_field

    s/$/\nfield::player = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,sink_player_ship::save_enemy_field/ ; x
    b copy
    :sink_player_ship::save_enemy_field
    
    s/[01]*\n[^\n]$//
    s/,$//
    b sink_player_ship::sink_loop
  }

  b return
}

:computer_move {
  x ; s/\(call_stack = [^\n]*\)/\1,computer_move::draw/ ; x
  b draw
  :computer_move::draw

  # Генерируем 
  x ; s/\(call_stack = [^\n]*\)/\1,computer_move::generate_move/ ; x
  b generate_computer_move
  :computer_move::generate_move

  # Посчитаем итоговую координату на поле
  x ; s/\(call_stack = [^\n]*\)/\1,computer_move::calculate_coordinates/ ; x
  b reverse_convert_coordinates
  :computer_move::calculate_coordinates

  s/$/\ngenerate_computer_move::cell_type/
  x ; s/\(call_stack = [^\n]*\)/\1,computer_move::get_ct/ ; x
  b get
  :computer_move::get_ct

  /H$/ {
    s/[^\n]*$/last_action_log/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::hit_get_log/ ; x
    b get
    :computer_move::hit_get_log
  
    # Получаем человекочитаемые координаты
    s/$/\nreverse_convert_coordinates::result_string/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::get_hit_coordinates/ ; x
    b get
    :computer_move::get_hit_coordinates
      
    s/\([^\n]*\)\n\([A-J][0-9]\)$/\nlast_action_log = \1_\2! Hit ya!/ 
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::hit_set_log/ ; x
    b set
    :computer_move::hit_set_log
   
    # Меняем символ для поля игрока
    s/$/\nset_symbol::symbol = D/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_hit_symbol/ ; x
    b set
    :computer_move::set_hit_symbol
    
    s/$/\nset_symbol::number = reverse_convert_coordinates::result_number/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_hit_number/ ; x
    b copy
    :computer_move::set_hit_number

    s/$/\nset_symbol::string = field::player/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_hit_string/ ; x
    b copy
    :computer_move::set_hit_string

    # Обновляем поле игрока
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::change_hit_string/ ; x
    b set_symbol 
    :computer_move::change_hit_string

    s/$/\nfield::player = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::perform_hit/ ; x
    b copy
    :computer_move::perform_hit

    # Анализируем попадание
    s/$/\nanalyze_ship_state::coordinate = reverse_convert_coordinates::result_number/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::prepare_analysis_coordinate/ ; x
    b copy
    :computer_move::prepare_analysis_coordinate
    
    s/$/\nanalyze_ship_state::ships = field::player_ships/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::prepare_analysis_ships/ ; x
    b copy
    :computer_move::prepare_analysis_ships
       
    s/$/\nanalyze_ship_state::field = field::player/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::prepare_analysis_field/ ; x
    b copy
    :computer_move::prepare_analysis_field

    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::analysis/ ; x
    b analyze_ship_state
    :computer_move::analysis

    s/$/\nanalyze_ship_state::result/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::get_analysis_result/ ; x
    b get
    :computer_move::get_analysis_result

    # Обычное попадание: маркируем соседние по диагонали клетки
    s/$/\nmark::coordinates = reverse_convert_coordinates::result_number/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::prepare_mark_coordinates/ ; x
    b copy
    :computer_move::prepare_mark_coordinates

    s/$/\nmark::field = field::player/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::prepare_mark_field/ ; x
    b copy
    :computer_move::prepare_mark_field

    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::mark_diagonal_cross/ ; x
    b mark_diagonal_cross
    :computer_move::mark_diagonal_cross

    s/$/\nfield::player = mark::field/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_diagonal_cross/ ; x
    b copy
    :computer_move::set_diagonal_cross
    
    /sunk$/ {
      s/\n*sunk$//
  
      # Обновим поле игрока
      s/$/\nmark::field = field::player/
      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::update_before_sink/ ; x
      b copy
      :computer_move::update_before_sink
    
      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::sink_ship/ ; x
      b sink_player_ship
      :computer_move::sink_ship
      
      # Получим клетки корабля
      s/$/\nmark::coordinates/
      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::get_hit_cell/ ; x
      b get
      :computer_move::get_hit_cell
      
      s/$/\nfield::player_ships/
      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::get_ship_list/ ; x
      b get
      :computer_move::get_ship_list
    
      s/$/\nmark::field = field::player/
      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::prepare_mark_field_2/ ; x
      b copy
      :computer_move::prepare_mark_field_2
      
      s/\([^\n]*\)$/ \1/
      s/\([01]*\)\n[^\n]* \([01,]*\)\1\([01,]*\)[^\n]*$/,\2\1\3/
      s/\([01,]*\)$/mark::ship = \1/
      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_ship_cells/ ; x
      b set
      :computer_move::set_ship_cells

      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::mark_circle/ ; x
      b mark_circle  
      :computer_move::mark_circle
    
      # Обновим поле игрока
      s/$/\nfield::player = mark::field/
      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::update_after_sink/ ; x
      b copy
      :computer_move::update_after_sink

      x ; s/\(call_stack = [^\n]*\)/\1,computer_move::check_lose/ ; x
      b check_lose
      :computer_move::check_lose
    }

     b computer_move
  }

  # Обработка промаха
  /·$/ {
    s/[^\n]*$/last_action_log/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::miss_get_log/ ; x
    b get
    :computer_move::miss_get_log
    
    # Получим человекочитаемые координаты 
    s/$/\nreverse_convert_coordinates::result_string/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::get_miss_coordinates/ ; x
    b get
    :computer_move::get_miss_coordinates
  
    s/\([^\n]*\)\n\([A-J][0-9]\)$/\nlast_action_log = \1_\2! OK, I missed.../ 
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::miss_set_log/ ; x
    b set
    :computer_move::miss_set_log
 
    # Изменим символ на поле игрока
    s/$/\nset_symbol::symbol = ~/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_missed_symbol/ ; x
    b set
    :computer_move::set_missed_symbol
    
    s/$/\nset_symbol::number = reverse_convert_coordinates::result_number/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_missed_number/ ; x
    b copy
    :computer_move::set_missed_number

    s/$/\nset_symbol::string = field::player/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::set_missed_string/ ; x
    b copy
    :computer_move::set_missed_string

    # Обновим поле игрока
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::change_missed_string/ ; x
    b set_symbol 
    :computer_move::change_missed_string

    s/$/\nfield::player = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,computer_move::perform_missed/ ; x
    b copy
    :computer_move::perform_missed

    b player_move
  }
}

:place_ship {
  # Инициализируем результат
  s/^.*$/place_ship::result = /
  x ; s/\(call_stack = [^\n]*\)/\1,place_ship::init_result/ ; x
  b set
  :place_ship::init_result

  # Инициализируем флаг границы, список координат и счетчик
  s/^.*$/0\n\n0/

  s/$/\nplace_ship::length/
  x ; s/\(call_stack = [^\n]*\)/\1,place_ship::get_length/ ; x
  b get
  :place_ship::get_length

  s/$/\nplace_ship::orientation/
  x ; s/\(call_stack = [^\n]*\)/\1,place_ship::get_orientation/ ; x
  b get
  :place_ship::get_orientation
  
  s/$/\nplace_ship::coordinates/
  x ; s/\(call_stack = [^\n]*\)/\1,place_ship::get_coordinates/ ; x
  b get
  :place_ship::get_coordinates

  # Считаем координаты
  :place_ship::collecting
    # Проверим флаг границы, вернем ошибку,если сейчас пересечем ее
    /^1/ b place_ship::invalid_placement

    # Если в очередной координате — не точка, вернем ошибку
    s/$/\nget_symbol::string = place_ship::field/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_field_string/ ; x
    b copy
    :place_ship::set_field_string
      
    s/\([01]*\)$/\1\nget_symbol::number = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_coordinate_to_get/ ; x
    b set
    :place_ship::set_coordinate_to_get
  
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::get_potential_cell/ ; x
    b get_symbol 
    :place_ship::get_potential_cell

    s/$/\nget_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::put_potential_cell/ ; x
    b get
    :place_ship::put_potential_cell
    /[~H]$/ b place_ship::invalid_placement

    # Добавим в список текущую координату
    s/^\([01]\)\n\([01,]*\)\n\([0-4]\n[0-4]\n[HVhv]\)\n\([01]*\)\n[·~HDX]$/\1\n\2,\4\n\3\n\4/
    
    # Выставим флаг границы, если мы ее достигли
    s/\([01]*\)$/\1\ndiv::first_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::div_set_1/ ; x
    b set
    :place_ship::div_set_1

    s/$/\ndiv::second_operand = 0001010/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::div_set_2/ ; x
    b set
    :place_ship::div_set_2

    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::execute_div/ ; x
    b div
    :place_ship::execute_div
    
    # Достигли правого края
    /[Hh]/ { 
      s/$/\ndiv::mod_result/
      x ; s/\(call_stack = [^\n]*\)/\1,place_ship::get_mod_result/ ; x
      b get
      :place_ship::get_mod_result

      /0001001$/ s/^0/1/
      s/\n[01]*$//
    }
    
    # Достигли нижнего края
    /[Vv]/ { 
      s/$/\ndiv::div_result/
      x ; s/\(call_stack = [^\n]*\)/\1,place_ship::get_div_result/ ; x
      b get
      :place_ship::get_div_result

      /0001001$/ s/^0/1/
      s/\n[01]*$//
    }

    # Смена координат
    # Зададим первое слагаемое
    s/\([01]*\)$/\nadd::first_operand = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::prepare_coordinate_change_1/ ; x
    b set
    :place_ship::prepare_coordinate_change_1
    
    # Второе слагаемое зависит от ориентации корабля
    /[Hh]/ s/$/\nadd::second_operand = 0000001/
    /[Vv]/ s/$/\nadd::second_operand = 0001010/

    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::prepare_coordinate_change_2/ ; x
    b set
    :place_ship::prepare_coordinate_change_2

    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::calculate_next_coordinate/ ; x
    b add
    :place_ship::calculate_next_coordinate

    s/$/add::result/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::get_next_coordinate/ ; x
    b get
    :place_ship::get_next_coordinate

    # Быстрый инкремент счетчика: для всего 4-х вариантов нет смысла тащить полную процедуру.
    # Поэтому мы и в бинарную форму не переводили длину корабля.
    s/^\([01]\)\n\([01,]*\)\n3/\1\n\2\n4/ ; s/^\([01]\)\n\([01,]*\)\n2/\1\n\2\n3/ ; s/^\([01]\)\n\([01,]*\)\n1/\1\n\2\n2/ ; s/^\([01]\)\n\([01,]*\)\n0/\1\n\2\n1/ 

    # Завершаем или продолжаем сбор координат
    /^[01]\n[01,]*\n\([1-4]\)\n\1/ {
      s/^[01]\n\([01,]*\).*$/\1/
      b place_ship::place
    }
    
    b place_ship::collecting

    :place_ship::invalid_placement
    {
      s/^.*$/place_ship::result = error/
      x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_error/ ; x
      b set
      :place_ship::set_error
      b return
    }

  :place_ship::place
  
  s/^\([01,]*\)$/\1\nplace_ship::result = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,place_ship::update_ship_placement/ ; x
  b set
  :place_ship::update_ship_placement
  
  # Обновляем поле
  :place_ship::loop
  /^,/ {
    # Mark ship cell
     s/$/\nset_symbol::symbol = H/
     x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_ship_symbol/ ; x
     b set
     :place_ship::set_ship_symbol
    
    s/\([01]*\)$/\1\nset_symbol::number = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_cell_number/ ; x
    b set
    :place_ship::set_cell_number

    s/$/\nset_symbol::string = place_ship::field/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_field/ ; x
    b copy
    :place_ship::set_field
  
     x ; s/\(call_stack = [^\n]*\)/\1,place_ship::mark_ship/ ; x
     b set_symbol 
    :place_ship::mark_ship

    s/$/\nplace_ship::field = set_symbol::result/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::update_field/ ; x
    b copy
    :place_ship::update_field

    # Маркируем соседей по диагонали
    s/\([01]*\)$/\1\nmark::coordinates = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::prepare_diagonal_mark_coordinates/ ; x
    b set
    :place_ship::prepare_diagonal_mark_coordinates

    s/$/\nmark::field = place_ship::field/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::prepare_diagonal_mark_field/ ; x
    b copy
    :place_ship::prepare_diagonal_mark_field

     x ; s/\(call_stack = [^\n]*\)/\1,place_ship::mark_diagonal_cross/ ; x
    b mark_diagonal_cross
    :place_ship::mark_diagonal_cross
    
    s/$/\nplace_ship::field = mark::field/
    x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_diagonal_cross/ ; x
    b copy
    :place_ship::set_diagonal_cross

    s/,[01]*$// # Удаляем обработанную координату
    b place_ship::loop
  }
  
  # Маркируем соседей по горизонтали и вертикали
  s/$/\nmark::ship = place_ship::result/
  x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_ship_to_circle/ ; x
  b copy
  :place_ship::set_ship_to_circle
   
   x ; s/\(call_stack = [^\n]*\)/\1,place_ship::mark_circle/ ; x
  b mark_circle  
  :place_ship::mark_circle
  
  s/$/\nplace_ship::field = mark::field/
  x ; s/\(call_stack = [^\n]*\)/\1,place_ship::set_circle/ ; x
  b copy
  :place_ship::set_circle

  b return
}

:set_player_ships {
  s/$/ships_to_place = ,1,1,1,1,2,2,2,3,3,4/
  x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::create_ships/ ; x
  b set
  :set_player_ships::create_ships

  :set_player_ships::place_loop
  {
    x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::draw/ ; x
    b draw
    :set_player_ships::draw
    
    s/^.*$/ships_to_place/
    x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::get_ships_to_place/ ; x
    b get
    :set_player_ships::get_ships_to_place
  
    s/^\n$//
    /^$/ b set_player_ships::end_placing

    s/\([^\n]*\),\([0-9]*\)$/\2\nships_to_place = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::remove_ship/ ; x
    b set
    :set_player_ships::remove_ship
  
    :set_player_ships::got_ship
    
    s/^\(.*\)$/You're placing a ship of length \1. Set its upper left square and its orientation.\nE.g. 'B5V' (vertical) or 'G2H' (horizontal)\n/ ; p
    s/^.*length \([0-9]\).*$/\1/
    N
    
    # Первичная валидация инпута
    /\n[A-Ja-j][0-9][hvHV]$/ b set_player_ships::valid_placement
    
    :set_player_ships::invalid_placement
    {
      s/$/\nships_to_place/
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::prepare_ship_to_return/ ; x
      b get
      :set_player_ships::prepare_ship_to_return
       
      s/\([0-9]\)\n[^\n]*\n\([,0-9]*\)$/ships_to_place = \2,\1/
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::return_ship/ ; x
      b set
      :set_player_ships::return_ship

      s/$/\nlast_action_log = Cannot place a ship. Try again./ 
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::log_invalid_place/ ; x
      b set
      :set_player_ships::log_invalid_place
      
      b set_player_ships::place_loop
    }

    :set_player_ships::valid_placement
    {
      s/$/\nlast_action_log = Place yet another ship./ 
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::log_valid_place/ ; x
      b set
      :set_player_ships::log_valid_place

      s/\([1-4]\)\n\(..\)\(.\)$/\1\n\3\nconvert_coordinates::coordinates = \2/
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::prepare_coordinate_conversion/ ; x
      b set
      :set_player_ships::prepare_coordinate_conversion
      
      # Конвертируем координаты
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::convert_coordinates/ ; x
      b convert_coordinates
      :set_player_ships::convert_coordinates

      s/$/\nconvert_coordinates::result/
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::set_start_coordinate/ ; x
      b get
      :set_player_ships::set_start_coordinate
    
      # Подготовим значения переменных для задания
      s/\([1-4]\)\n\(.\)\n\([01]*\)$/place_ship::field = field::player\nplace_ship::length = \1\nplace_ship::coordinates = \3\nplace_ship::orientation = \2/
      
      # Задаем все переменные
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::set_orientation/ ; x
      b set
      :set_player_ships::set_orientation
       
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::set_coordinates/ ; x
      b set
      :set_player_ships::set_coordinates
       
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::set_length/ ; x
      b set
      :set_player_ships::set_length
       
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::set_field/ ; x
      b copy
      :set_player_ships::set_field

      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::place_ship/ ; x
      b place_ship
      :set_player_ships::place_ship

      s/$/\nplace_ship::result/
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::get_placing_result/ ; x
      b get
      :set_player_ships::get_placing_result

      /error/ {
        s/^.*$/\nplace_ship::length/
        x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::handle_placing_error/ ; x
        b get
        :set_player_ships::handle_placing_error
        s/$/\n/
        b set_player_ships::invalid_placement
      }

      s/$/\nfield::player = place_ship::field/
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::update_field/ ; x
      b copy
      :set_player_ships::update_field

      s/$/\nfield::player_ships/
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::get_player_ships/ ; x
      b get
      :set_player_ships::get_player_ships

      s/^,\([01,]*\)\n\([^\n]*\)$/field::player_ships = \2 \1/
      s/  / / # Hack for the first replacement
      x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::update_player_ships/ ; x
      b set
      :set_player_ships::update_player_ships
    }
    
    b set_player_ships::place_loop
  }

  # Превращаем волны обратно в точки
  :set_player_ships::end_placing
  s/^.*$/field::player/
  x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::prepare_final_update/ ; x
  b get
  :set_player_ships::prepare_final_update
  
  s/~/·/g
   
  s/^\n*\(.*\)$/\nfield::player = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::final_update/ ; x
  b set
  :set_player_ships::final_update

  s/$/\nlast_action_log = Let the battle begin!/ 
  x ; s/\(call_stack = [^\n]*\)/\1,set_player_ships::log_game_start/ ; x
  b set
  :set_player_ships::log_game_start

  b return
}

:select_difficulty {
  s/^.*$/\c[[H\c[[J=== Sed Battleship by Red Void ===\n\nSelect a difficulty level:\n1. I can win\n2. Bring it on\n3. Hurt me plenty\n4. Hardcore\n5. Nightmare!\n/ 
  p
  n
  /^[1-5]$/ {
    s/1/001/ ; s/2/010/ ; s/3/011/ ; s/4/100/ ; s/5/101/
    s/\([01]*\)$/\nluck = 00000000000000000000000000000\1/ 
    x ; s/\(call_stack = [^\n]*\)/\1,select_difficulty::set_luck/ ; x
    b set_variable
    :select_difficulty::set_luck
    b return
  }
  s/^.*$//
  b select_difficulty
}

:rng_seed {
  s/$/\nfield::player_ships/
  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::get_rng_seed_parts_1/ ; x
  b get
  :rng_seed::get_rng_seed_parts_1

  # Сжатие без потерь: 100 -> 76 битов
  s/\([^01,][01]\{6\}0\)\(,[01]\{6\}1\)[^ ]*/\11/g
  s/\([^01,][01]\{6\}1\)\(,[01]\{6\}0\)[^ ]*/\11/g
  s/\([^01,][01]*\),[01,]*/\10/g
  
  s/$/\nluck/
  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::get_rng_seed_parts_2/ ; x
  b get
  :rng_seed::get_rng_seed_parts_2
   
  # Сжатие с потерями (но только в теории): 32 -> 4 бита
  s/[01]*\([01]\{4\}\)$/\1/
  s/[\n ]//g

  s/$/\nrng::M/
  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::get_rng_seed_parts_3/ ; x
  b get
  :rng_seed::get_rng_seed_parts_3

  # В делимом у нас 80 битов, а в делителе 32
  # Поэтому добавим в делитель еще 48 ведущих нулей
  s/\([01]*\)\n\([01]*\)$/div::first_operand = \1\ndiv::second_operand = 000000000000000000000000000000000000000000000000\2/
  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::set_divisor/ ; x
  b set
  :rng_seed::set_divisor

  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::set_dividend/ ; x
  b set
  :rng_seed::set_dividend

  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::perform_division/ ; x
  b div
  :rng_seed::perform_division
 
  s/^.*$/div::mod_result/
  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::get_raw_seed/ ; x
  b get
  :rng_seed::get_raw_seed
 
  s/.*\([01]\{32\}\)$/rng::current_state = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,rng_seed::set_seed/ ; x
  b set 
  :rng_seed::set_seed

  b return
}

:set_computer_ships {
  s/$/ships_to_place = ,1,1,1,1,2,2,2,3,3,4/
  x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::create_ships/ ; x
  b set
  :set_computer_ships::create_ships

  :set_computer_ships::place_loop
  {
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::draw/ ; x
    b draw
    :set_computer_ships::draw
    
    s/^.*$/ships_to_place/
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::get_ships_to_place/ ; x
    b get
    :set_computer_ships::get_ships_to_place
  
    s/^\n$//
    /^$/ b set_computer_ships::end_placing

    s/\([^\n]*\),\([0-9]*\)$/\2\nships_to_place = \1/
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::remove_ship/ ; x
    b set
    :set_computer_ships::remove_ship
  
    :set_computer_ships::got_ship
    
    # Генерируем случайное число
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::gen_random/ ; x
    b rng
    :set_computer_ships::gen_random
     
    s/$/\nrng::current_state/
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::get_random/ ; x
    b get
    :set_computer_ships::get_random
  
    s/0$/\nH/ ; s/1$/\nV/
    s/[01]*\([01]\{20\}\)\n\([HV]\)$/\2\ndiv::first_operand = \1\ndiv::second_operand = 00000000000001100100/
      
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::prepare_coordinate_conversion_1/ ; x
    b set
    :set_computer_ships::prepare_coordinate_conversion_1
     
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::prepare_coordinate_conversion_2/ ; x
    b set
    :set_computer_ships::prepare_coordinate_conversion_2
     
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::convert_coordinates/ ; x
    b div
    :set_computer_ships::convert_coordinates
     
    s/$/\ndiv::mod_result/
    x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::get_coordinates/ ; x
    b get
    :set_computer_ships::get_coordinates
  
    s/[01]*\([01]\{7\}\)$/\1/

    b set_computer_ships::valid_placement
    
    :set_computer_ships::invalid_placement
    {
      s/$/\nships_to_place/
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::prepare_ship_to_return/ ; x
      b get
      :set_computer_ships::prepare_ship_to_return
       
      s/\([0-9]\)\n[^\n]*\n\([,0-9]*\)$/ships_to_place = \2,\1/
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::return_ship/ ; x
      b set
      :set_computer_ships::return_ship

      b set_computer_ships::place_loop
    }

    :set_computer_ships::valid_placement
    {
      s/$/\nlast_action_log/ 
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::get_current_log/ ; x
      b get
      :set_computer_ships::get_current_log
       
      s/\([^\n]*\)$/last_action_log = \1./ 
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::log_valid_place/ ; x
      b set
      :set_computer_ships::log_valid_place

      # Конвертируем длину, готовим переменные для задания значений
      s/\([1-4]\)\n\(.\)\n\([01]*\)$/place_ship::field = field::computer\nplace_ship::length = \1\nplace_ship::coordinates = \3\nplace_ship::orientation = \2/
      
      # Задаем все переменные
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::set_orientation/ ; x
      b set
      :set_computer_ships::set_orientation
       
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::set_coordinates/ ; x
      b set
      :set_computer_ships::set_coordinates
       
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::set_length/ ; x
      b set
      :set_computer_ships::set_length
       
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::set_field/ ; x
      b copy
      :set_computer_ships::set_field

      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::place_ship/ ; x
      b place_ship
      :set_computer_ships::place_ship

      s/$/\nplace_ship::result/
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::get_placing_result/ ; x
      b get
      :set_computer_ships::get_placing_result

      /error/ {
        s/^.*$/\nplace_ship::length/
        x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::handle_placing_error/ ; x
        b get
        :set_computer_ships::handle_placing_error
        s/$/\n/
        b set_computer_ships::invalid_placement
      }

      s/$/\nfield::computer = place_ship::field/
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::update_field/ ; x
      b copy
      :set_computer_ships::update_field

      s/$/\nfield::computer_ships/
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::get_computer_ships/ ; x
      b get
      :set_computer_ships::get_computer_ships

      s/^,\([01,]*\)\n\([^\n]*\)$/field::computer_ships = \2 \1/
      s/  / / # Hack for the first replacement
      x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::update_computer_ships/ ; x
      b set
      :set_computer_ships::update_computer_ships
    }
    
    b set_computer_ships::place_loop
  }

  # Превращаем оставшиеся точки в волны
  :set_computer_ships::end_placing
  s/^.*$/field::computer/
  x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::prepare_final_update/ ; x
  b get
  :set_computer_ships::prepare_final_update
  
  s/·/~/g
   
  s/^\n*\(.*\)$/\nfield::computer = \1/
  x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::final_update/ ; x
  b set
  :set_computer_ships::final_update
   
  s/$/\nlast_action_log = Let the battle begin!/ 
  x ; s/\(call_stack = [^\n]*\)/\1,set_computer_ships::log_game_start/ ; x
  b set
  :set_computer_ships::log_game_start

  b return
}

:draw
{
  s/^.*$//

  s/$/\nfield::player/
  x ; s/\(call_stack = [^\n]*\)/\1,draw::get_field1/ ; x
  b get
  :draw::get_field1

  s/$/\nfield::suggestions/
  x ; s/\(call_stack = [^\n]*\)/\1,draw::get_field2/ ; x
  b get
  :draw::get_field2
 
  s/\([·~HDX]\)/\1 /g

  s/$/\n   | \c[[1m0 1 2 3 4 5 6 7 8 9\c[[0m            | \c[[1m0 1 2 3 4 5 6 7 8 9\c[[0m/
  s/$/\n---+--------------------         ---+--------------------/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mA\c[[0m | \1         \c[[1mA\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mB\c[[0m | \1         \c[[1mB\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mC\c[[0m | \1         \c[[1mC\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mD\c[[0m | \1         \c[[1mD\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mE\c[[0m | \1         \c[[1mE\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mF\c[[0m | \1         \c[[1mF\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mG\c[[0m | \1         \c[[1mG\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mH\c[[0m | \1         \c[[1mH\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\([·~HDX ]\{20\}\)\([·~HDX ]*\)\n\(.*\)$/\2\n\4\n\5\
 \c[[1mI\c[[0m | \1         \c[[1mI\c[[0m | \3/
  s/^\([·~HDX ]\{20\}\)\n\([·~HDX ]\{20\}\)\n\(.*\)$/\3\
 \c[[1mJ\c[[0m | \1         \c[[1mJ\c[[0m | \2/

  # Раскрасим элементы поля
  s/ D/ \c[[33mD\c[[0m/g
  s/ X/ \c[[31mX\c[[0m/g
  s/ H/ \c[[32mH\c[[0m/g
  s/ ~/ \c[[34m~\c[[0m/g

  # Добавим лог последних действий
  s/$/\n\nlast_action_log/
  x ; s/\(call_stack = [^\n]*\)/\1,draw::get_log/ ; x
  b get
  :draw::get_log

  # Отформатируем лог: заменим подчеркивания на переносы
  s/_/\n/g 
  # Добавим еще одну линию, очистку экрана и заголовок
  s/$/\n/
  s/^/\c[[H\c[[J           === Sed Battleship by Red Void ===\n\n/
  # Выведем поля
  p
  # Снова очистим pattern space
  s/^.*$//

  b return
}