seshoumara's stats

#!/usr/bin/sed -nrf

#################################################### WARNING ####################################################
#                               Back-up any file before you open it in this editor!!                            #
#################################################################################################################

:_Problem
    # text editor
    # https://cg.esolangs.gay/62/
:_Restrictions
    # run as: FILE="file.txt" ./cg62_editor.sed (stdin used for input of commands)
    # escape character (\o033) and "EOF" keyword are reserved, can't be in the file
    # errors aren't handled, they close the editor instantly (no save!)
    # vertical scrolling isn't implemented, cursor can go out of screen (use file with few lines to test)


################################################# SETUP #########################################################

:init
	1v;1x
	1b f5
1!b apply_cmd

################################################# COMMANDS ######################################################

:apply_cmd
	/^u$/		{	x;b u		}
	/^uu$/		{	x;b uu		}
	/^d$/		{	x;b d		}
	/^dd$/		{	x;b dd		}
	/^l$/		{	x;b l		}
	/^ll$/		{	x;b ll		}
	/^r$/		{	x;b r		}
	/^rr$/		{	x;b rr		}
	/^tab$/		{	x;b tab		}
	/^enter$/	{	x;b enter	}
	/^i ./		{	x;b i		}
	/^k$/		{	x;b k		}
	/^kk$/		{	x;b kk		}
	/^kkk$/		{	x;b kkk		}
	/^clear$/	{	x;b clear	}
	/^f5$/		{	x;b f5		}
	/^s$/		{	x;b s		}
	/^quit$/	{	x;b quit	}
	/^help$/	{	x;b help	}
	s@.*@Input error: unknown command!.@p
b quit_error

:u
	/^0/b display
	s:([^\n]*\n?[^\n]*)(\o033\[91m>\o033\[0m):\2\1:
	s:^(\o033\[91m>\o033\[0m)1:1\1:
b display

:uu
	/^1/s:^1(.*)(\o033\[91m>\o033\[0m):1\2\1:
b display

:d
	/^1/s:(\o033\[91m>\o033\[0m)([^\n]*\n?):\2\1:
b display

:dd
	/^1/s:(\o033\[91m>\o033\[0m)(.*):\2\1:
b display

:l
	/^1/s:^(1.*)(.)(\o033\[91m>\o033\[0m):\1\3\2:
b display

:ll
	/^0/b display
	s:([^\n]*)(\o033\[91m>\o033\[0m):\2\1:
	s:^(\o033\[91m>\o033\[0m)1:1\1:
b display

:r
	/^1/s:(\o033\[91m>\o033\[0m)(.):\2\1:
b display

:rr
	/^1/s:(\o033\[91m>\o033\[0m)([^\n]*):\2\1:
b display

:tab
	/^1/s:\o033\[91m>\o033\[0m:\t&:
b display

:enter
	/^1/s:\o033\[91m>\o033\[0m:\n&:
b display

:i
	/^0/b display
	x
	s:^i ::
	/\o033/{
		s@.*@Input error: ESCAPE is a reserved character!@p
		b quit_error
	}
	/EOF/{
		s@.*@Input error: 'EOF' is a reserved keyword!@p
		b quit_error
	}
	G;h;x
	s:^([^\n]+)\n(1.*)(\o033\[91m>\o033\[0m):\2\1\3:
b display

:k
	/^1/s:(\o033\[91m>\o033\[0m).:\1:
b display

:kk
	/^1/s:(\o033\[91m>\o033\[0m)[^\n]*:\1:
b display

:kkk
	/^1/s:(\o033\[91m>\o033\[0m).*:\1:
b display

:clear
	/^1/s:.*:1\o033[91m>\o033[0m:
b display

:f5
	/^0/b display
	s:.*:cat "$FILE":e
	#how to test if file doesn't exist?
	/\o033/{
		s@.*@File error: ESCAPE is a reserved character!@p
		b quit_error
	}
	/EOF/{
		s@.*@File error: 'EOF' is a reserved keyword!@p
		b quit_error
	}
	s:^:1\o033[91m>\o033[0m:
b display

:s
	/^0/b display
	h;x
	s:^1::
	s:\o033\[91m>\o033\[0m::
	s:.*:cat << 'EOF' > "$FILE"\n&\nEOF:e
	x
b display

:quit
b quit_ok

:help
	/^0/{
		s::1:
		b display
	}
	s:^1:0:
b display

:get_help
	#this should have been part of :help, but then both pattern and hold space would be occupied
	#display needs one free space to call to bash and other things, so the help text is JIT generated
	s:.*:u    move cursor to the start of the line above\n:
	s:$:uu    move cursor to the start of the file\n:
	s:$:d     move cursor to the start of the line below\n:
	s:$:dd    move cursor to the end of the file\n\n:
	s:$:l     move cursor to the left\n:
	s:$:ll    move cursor to the start of the current line\n:
	s:$:r     move cursor to the right\n:
	s:$:rr    move cursor to the end of the current line\n\n:
	s:$:tab   insert tab\n:
	s:$:enter insert enter\n:
	s:$:i TXT insert TXT characters (except tab and enter)\n\n:
	s:$:k     kill character after the cursor\n:
	s:$:kk    kill all characters after the cursor till the end of the current line\n:
	s:$:kkk   kill all characters after the cursor till the end of the file\n:
	s:$:clear kill all characters from the file\n\n:
	s:$:f5    reload content from the file on disk (unsaved changes lost)\n:
	s:$:s     save content to file on disk\n:
	s:$:quit  quit, discarding all changes! (works in help mode)\n\n:
	s:$:help  toggle this help screen (works in help mode):
b continue_display

################################################# DISPLAY #######################################################

:display
	/^1/{
		h;x
		s:::
	}
	/^0/{
		x
		b get_help
		:continue_display
	}
	:number_lines_and_wrap
		#Shit! No time left, let's cheat :D
		s@.*@cat -n << 'EOF'|sed 's:^[ \t]*::;s:\t:):'|fold -$(tput cols)\n&\nEOF@e
	#clear screen
	s:^:\o033[H\o033[J:
	s@$@\n~\nEnter command (type help for a list of available commands):@p
b EOS

:get_terminal_stats
	#sed can't directly access environmental var $FILE and terminal size
	s:.*:echo "$FILE";tput cols;tput lines:e
b#?

################################################# THE END #######################################################

:quit_ok
	Q 0

:quit_error
	Q 1

:EOS

#!/usr/bin/sed -nrf

s:.*::
:loop
	y:01:10:
	x;G
	s:^\n$:0&:
	s:(\n)(.*):\2\1:p
	s:\n$::;h
/^(.{255}){255}.*$/!b loop
q

#!/usr/bin/dc -f

[Problem]c
	# spirograph: hypotrochoids and epitrochoids (echo 'R r d' as input*)
	# https://cg.esolangs.gay/43/
[Restrictions]c
	# *negative numbers are given using _ prefix, not - which is a dc command
	# the SVG shape can't be saved to a file, only printed :(


[main]c
[
	#save each input parameter to its own register
	?sdsrsR
	#based on r's sign execute the approppriate shape drawing function
	0lr>hlex
]sm


#TODO: fix it!!
[hypotrochoids]c
[
	#gen angle range using LCM(r,R)/R as scaling factor
	lrlRlLxlR/dsf
	360*lSx10k
	#calculate plot coordinates, stored in x and y arrays
	[
		ddddd
		#calculate x
		lRlr-rlAxlCx*r
		lRlr-lr/*lAxlCxld*
		+r:x
		#calculate y
		lRlr-rlAxlCx d*1r-lVxv *r
		lRlr-lr/*lAxlCx d*1r-lVxv ld*
		-r:y
		#loop back if there's still an angle to process
		z0r>_
	]ds_x
	#print then quit
	0klpxqq
]sh


#TODO: fix it!!
[epitrochoids]c
[
	#make r positive
	lrlVxsr
	#gen angle range using no (1) scaling factor
	1dsf
	360*lSx10k
	#calculate plot coordinates, stored in x and y arrays
	[
		ddddd
		#calculate x
		lRlr+rlAxlCx*r
		lRlr+lr/*lAxlCxld*
		-r:x
		#calculate y
		lRlr+rlAxlCx d*1r-lVxv *r
		lRlr+lr/*lAxlCx d*1r-lVxv ld*
		-r:y
		#loop back if there's still an angle to process
		z0r>_
	]ds_x
	#print then quit
	0klpxqq
]se


[print]c
[
	#gen angle range
	lf360*lSx
	#print SVG header
	[<?xml version="1.0" encoding="UTF-8" standalone="no"?>]nAP
	[<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" ]n
	["http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">]nAP
	[<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg" ]n
	[xmlns:xlink="http://www.w3.org/1999/xlink">]nAP
	[  <path d="]n
	#add start point
	d[M ]n;xn[ ]nr;yn
	[
		#add line segment
		d[ L ]n;xn[ ]nr;yn
		#loop back if there's still an angle to process
		z0r>_
	]ds_x
	#print SVG footer
	[ Z"/>]nAP[</svg>]nAP
]sp


#TODO: fix it!!
######################### MATH #########################

#3: [stop] -> [0 1 2 3 ... stop]
[seq]c
[
	0r
	[
		#push increment and float stop to top
		rd1+3R
		#push [increment stop]
		d3Rd_4Rr
		#loop back if stop != increment
		!=_
	]ds_x
	#pop stop
	d-+
]sS


#2: [a b] -> [GCD]
[GCD]c
[
	#change to [max min]
	d3Rd_4Rr
	[r]s_>_
	#Euclidean algorithm
	[
		#change to [min max%min]
		d_3R%
		#loop back on non-zero remainder
		d0r>_
	]ds_x
	#pop remainder (0), GCD=min
	+
]sG


#2: [a b] -> [LCM]
[LCM]c
[
	#push [a b]
	d3Rd_4Rr
	#change to [|ab| GCD]
	*lVx
	_3RlGx
	#divide to get LCM
	/
]sL


#1: [a] -> [cos]
[COS]c
[
	10k
	#Taylor serie
	dddddddd*******40320/r
	dddddd*****720/0r-r
	dddd***24/r
	d*2/0r-
	1++++0k
]sC


#1: [degrees] -> [radians]
[d2g]c
[
	10k
	#push 1 rad
	180 3.1415926535 /
	#convert
	/0k
]sA


#1: [a] -> [abs]
[abs]c
[
	10kd*v0k
]sV

########################################################

lmx

#!/usr/bin/sed -nrf

:_Problem
	# I-calc: calculator with I-style operator precedence
	# https://cg.esolangs.gay/38/
:_Restrictions
    # Division by zero is currently defined as infinite runtime!
    # Division rounds down to closest int (ignores sign): truncates!
    # Incredibly slow computation beyond 4 digit numbers!


b DEBUG
:main
    #multiple-digit numbers
    /[0-9][0-9]+/b undefined
    #unary operators and uneven whitespace around operators
    h
    t loop_u
    :loop_u
        s:^[0-9]([ \t]*)[-+*/]\1([0-9]):\2:
    t loop_u
    /^[0-9]$/!b undefined
    g
    #compute and print expression result
    \:[-+*/]:b parse_expression
    :done
    p
b EOS


:parse_expression
l
    #loop one operator at a time, using ; to point to one
    s:^:>:
    :loop_pe_1
        s:>([ \t0-9]+):\1>:
        #count whitespaces around current operator
        s:>:#0>:
        :loop_pe_2
            \:(>[-+*/])[ \t]:{
                s::\1:
                s:#([0-9]+)>:#<INCp>\1#result_ip_pe<pCNI>>:
                b incr_pos
                :result_ip_pe
                    s:<INCp>([0-9]+)[^<]+<pCNI>:\1:
                b loop_pe_2
            }
        s:[ \t]*#([0-9]+)>([-+*/]):#\1#\2>:
    \:>.*[-+*/]:b loop_pe_1
    s:>::
l
    #new counter: highest precedence (0) first, lowest last
    s:^:-1,:
    :loop_pe_3
        s:^(-?[0-9]+):<INC>\1#result_i_pe<CNI>:
        b incr
        :result_i_pe
            s:<INC>([0-9]+)[^<]+<CNI>:\1:
        #match operator with whitespaces/precedence = counter
        s:,:,>:
        :loop_pe_4
            s:>([#_0-9]+):\1>:
l
            b calc_bracket
            :result_bracket
l
        \:>.*[-+*/]:b loop_pe_4
        s:>::
    \:[-+*/]:b loop_pe_3
    s:[0-9]+,::
    s:^_:-:
b done


#negative numbers are prefixed with _ instead, not - (like in dc)
:calc_bracket
    #sub
    \:^([0-9]+)(,.*)\b(_?[0-9]+)#\1#>-(_?[0-9]+):{
        s::\1\2><SUB>\3 \4#result_s_cb<BUS>:
        s:(<SUB>)_:\1-:
        s:(<SUB>-?[0-9]+ )_:\1-:
        b sub
        :result_s_cb
            s:(<SUB>)-:\1_:
            s:<SUB>(_?[0-9]+)[^<]+<BUS>:\1:
        b result_bracket
    }
    #add
    \:^([0-9]+)(,.*)\b(_?[0-9]+)#\1#>\+(_?[0-9]+):{
        s::\1\2><ADD>\3 \4#result_a_cb<DDA>:
        s:(<ADD>)_:\1-:
        s:(<ADD>-?[0-9]+ )_:\1-:
        b add
        :result_a_cb
            s:(<ADD>)-:\1_:
            s:<ADD>(_?[0-9]+)[^<]+<DDA>:\1:
        b result_bracket
    }
    #mult
    \:^([0-9]+)(,.*)\b(_?[0-9]+)#\1#>\*(_?[0-9]+):{
        s::\1\2><MULT>\3 \4#result_mm_cb<TLUM>:
        s:(<MULT>)_:\1-:
        s:(<MULT>-?[0-9]+ )_:\1-:
        b mult
        :result_mm_cb
            s:(<MULT>)-:\1_:
            s:<MULT>(_?[0-9]+)[^<]+<TLUM>:\1:
        b result_bracket
    }
    #div
    \:^([0-9]+)(,.*)\b(_?[0-9]+)#\1#>/(_?[0-9]+):{
        s::\1\2><DIV>\3 \4#result_dv_cb<VID>:
        s:(<DIV>)_:\1-:
        s:(<DIV>-?[0-9]+ )_:\1-:
        b div
        :result_dv_cb
            s:(<DIV>)-:\1_:
            s:<DIV>(_?[0-9]+)[^<]+<VID>:\1:
        b result_bracket
    }
    s:>([-+*/]):\1>:
b result_bracket


:undefined
    s:.*:undefined:p
b EOS


:user_redirects
    /##result_ip_pe<pCNI>/b result_ip_pe
    /##result_i_pe<CNI>/b result_i_pe
    /##result_s_cb<BUS>/b result_s_cb
    /##result_a_cb<DDA>/b result_a_cb
    /##result_mm_cb<TLUM>/b result_mm_cb
    /##result_dv_cb<VID>/b result_dv_cb
b EOS


:DEBUG
	#test if GNU extensions are supported
	1v
b main


######################### MATH LIB 2.0 #########################

#1-2: <DIV>14 5#label<VID> -> <DIV>2##label<VID>
#1-2: <DIV>-27 3#label<VID> -> <DIV>-9##label<VID>
#1-2: <DIV>0 -5#label<VID> -> <DIV>0##label<VID>
#1-2: <DIV>-15 -5#label<VID> -> <DIV>3##label<VID>
#1-2: <DIV>9 0#label<VID> -> INFINITE RUNTIME!!
:div
	s:<DIV>-?[0-9]+:&;:
    b next_dv
    :loop_dv
        /(<DIV>)-([0-9]+) -([0-9]+);/{
            s::\1<DIVp>\2 \3#result_dvp_dv_1<pVID>;:
            b div_pos
            :result_dvp_dv_1
                s:<DIVp>([0-9]+)[^<]+<pVID>:\1:
            b next_dv
        }
        /(<DIV>)-([0-9]+) ([0-9]+);/{
            s::\1<DIVp>\2 \3#result_dvp_dv_2<pVID>;:
            b div_pos
            :result_dvp_dv_2
                s:<DIVp>([0-9]+)[^<]+<pVID>:-\1:
            b next_dv
        }
        /(<DIV>)([0-9]+) -([0-9]+);/{
            s::\1<DIVp>\2 \3#result_dvp_dv_3<pVID>;:
            b div_pos
            :result_dvp_dv_3
                s:<DIVp>0[^<]+<pVID>:0:
                s:<DIVp>([0-9]+)[^<]+<pVID>:-\1:
            b next_dv
        }
        s:(<DIV>)([0-9]+) ([0-9]+);:\1<DIVp>\2 \3#result_dvp_dv_4<pVID>;:
        b div_pos
        :result_dvp_dv_4
            s:<DIVp>([0-9]+)[^<]+<pVID>:\1:
    :next_dv
        /;#[^<]+<VID>/b print_dv
        s:(<DIV>[^;]+);( -?[0-9]+):\1\2;:
    b loop_dv
    :print_dv
        s:;(#[^<]+<VID>):#\1:
b redirect


#1+: <MULT>9 1 -14 -10#label<TLUM> -> <MULT>1260##label<TLUM>
:mult
	s:<MULT>-?[0-9]+:&;:
    b next_mm
    :loop_mm
        /(<MULT>)-([0-9]+) -([0-9]+);/{
            s::\1<MULTp>\2 \3#result_mmp_mm_1<pTLUM>;:
            b mult_pos
            :result_mmp_mm_1
                s:<MULTp>([0-9]+)[^<]+<pTLUM>:\1:
            b next_mm
        }
        /(<MULT>)-([0-9]+) ([0-9]+);/{
            s::\1<MULTp>\2 \3#result_mmp_mm_2<pTLUM>;:
            b mult_pos
            :result_mmp_mm_2
                s:<MULTp>([0-9]+)[^<]+<pTLUM>:-\1:
            b next_mm
        }
        /(<MULT>)([0-9]+) -([0-9]+);/{
            s::\1<MULTp>\2 \3#result_mmp_mm_3<pTLUM>;:
            b mult_pos
            :result_mmp_mm_3
                s:<MULTp>([0-9]+)[^<]+<pTLUM>:-\1:
            b next_mm
        }
        s:(<MULT>)([0-9]+) ([0-9]+);:\1<MULTp>\2 \3#result_mmp_mm_4<pTLUM>;:
        b mult_pos
        :result_mmp_mm_4
            s:<MULTp>([0-9]+)[^<]+<pTLUM>:\1:
    :next_mm
        /;#[^<]+<TLUM>/b print_mm
        s:(<MULT>[^;]+);( -?[0-9]+):\1\2;:
    b loop_mm
    :print_mm
        s:;(#[^<]+<TLUM>):#\1:
b redirect


#1-2: <SUB>14 9#label<BUS> -> <SUB>5##label<BUS>
#1-2: <SUB>-14 9#label<BUS> -> <SUB>-23##label<BUS>
#1-2: <SUB>0 -9#label<BUS> -> <SUB>9##label<BUS>
#1-2: <SUB>-14 -9#label<BUS> -> <SUB>-5##label<BUS>
:sub
	s:<SUB>-?[0-9]+:&;:
    b next_s
    :loop_s
        /(<SUB>)-([0-9]+) -([0-9]+);/{
            s::\1<SUBp>\3 \2#result_sp_s_1<pBUS>;:
            b sub_pos
            :result_sp_s_1
                s:<SUBp>(-?[0-9]+)[^<]+<pBUS>:\1:
            b next_s
        }
        /(<SUB>)-([0-9]+) ([0-9]+);/{
            s::\1<ADDp>\2 \3#result_ap_s_1<pDDA>;:
            b add_pos
            :result_ap_s_1
                s:<ADDp>([0-9]+)[^<]+<pDDA>:-\1:
            b next_s
        }
        /(<SUB>)([0-9]+) -([0-9]+);/{
            s::\1<ADDp>\2 \3#result_ap_s_2<pDDA>;:
            b add_pos
            :result_ap_s_2
                s:<ADDp>([0-9]+)[^<]+<pDDA>:\1:
            b next_s
        }
        s:(<SUB>)([0-9]+) ([0-9]+);:\1<SUBp>\2 \3#result_sp_s_2<pBUS>;:
        b sub_pos
        :result_sp_s_2
            s:<SUBp>(-?[0-9]+)[^<]+<pBUS>:\1:
    :next_s
        /;#[^<]+<BUS>/b print_s
        s:(<SUB>[^;]+);( -?[0-9]+):\1\2;:
    b loop_s
    :print_s
        s:;(#[^<]+<BUS>):#\1:
b redirect


#1+: <ADD>9 14 0 -8 -16#label<DDA> -> <ADD>-1##label<DDA>
:add
	s:<ADD>-?[0-9]+:&;:
    b next_a
    :loop_a
        /(<ADD>)-([0-9]+) -([0-9]+);/{
            s::\1<ADDp>\2 \3#result_ap_a_1<pDDA>;:
            b add_pos
            :result_ap_a_1
                s:<ADDp>([0-9]+)[^<]+<pDDA>:-\1:
            b next_a
        }
        /(<ADD>)-([0-9]+) ([0-9]+);/{
            s::\1<SUBp>\3 \2#result_sp_a_1<pBUS>;:
            b sub_pos
            :result_sp_a_1
                s:<SUBp>(-?[0-9]+)[^<]+<pBUS>:\1:
            b next_a
        }
        /(<ADD>)([0-9]+) -([0-9]+);/{
            s::\1<SUBp>\2 \3#result_sp_a_2<pBUS>;:
            b sub_pos
            :result_sp_a_2
                s:<SUBp>(-?[0-9]+)[^<]+<pBUS>:\1:
            b next_a
        }
        s:(<ADD>)([0-9]+) ([0-9]+);:\1<ADDp>\2 \3#result_ap_a_2<pDDA>;:
        b add_pos
        :result_ap_a_2
            s:<ADDp>([0-9]+)[^<]+<pDDA>:\1:
    :next_a
        /;#[^<]+<DDA>/b print_a
        s:(<ADD>[^;]+);( -?[0-9]+):\1\2;:
    b loop_a
    :print_a
        s:;(#[^<]+<DDA>):#\1:
b redirect


#1+: <MAX>110 34 0 -34 -110#label<XAM> -> <MAX>110##label<XAM>
:max
    s:<MAX>-?[0-9]+:&;:
    b next_M
    :loop_M
        /(<MAX>)-([0-9]+) -([0-9]+);/{
            s::\1<MINp>\2 \3#result_mp_M<pNIM>;:
            b min_pos
            :result_mp_M
                s:<MINp>([0-9]+)[^<]+<pNIM>:-\1:
            b next_M
        }
        /(<MAX>)(-[0-9]+) ([0-9]+);/{
            s::\1\3;:
            b next_M
        }
        /(<MAX>)([0-9]+) (-[0-9]+);/{
            s::\1\2;:
            b next_M
        }
        s:(<MAX>)([0-9]+) ([0-9]+);:\1<MAXp>\2 \3#result_Mp_M<pXAM>;:
        b max_pos
        :result_Mp_M
            s:<MAXp>([0-9]+)[^<]+<pXAM>:\1:
    :next_M
        /;#[^<]+<XAM>/b print_M
        s:(<MAX>[^;]+);( -?[0-9]+):\1\2;:
    b loop_M
    :print_M
        s:;(#[^<]+<XAM>):#\1:
b redirect


#1+: <MIN>110 34 0 -34 -110#label<NIM> -> <MIN>-110##label<NIM>
:min
    s:<MIN>-?[0-9]+:&;:
    b next_m
    :loop_m
        /(<MIN>)-([0-9]+) -([0-9]+);/{
            s::\1<MAXp>\2 \3#result_Mp_m<pXAM>;:
            b max_pos
            :result_Mp_m
                s:<MAXp>([0-9]+)[^<]+<pXAM>:-\1:
            b next_m
        }
        /(<MIN>)(-[0-9]+) ([0-9]+);/{
            s::\1\2;:
            b next_m
        }
        /(<MIN>)([0-9]+) (-[0-9]+);/{
            s::\1\3;:
            b next_m
        }
        s:(<MIN>)([0-9]+) ([0-9]+);:\1<MINp>\2 \3#result_mp_m<pNIM>;:
        b min_pos
        :result_mp_m
            s:<MINp>([0-9]+)[^<]+<pNIM>:\1:
    :next_m
        /;#[^<]+<NIM>/b print_m
        s:(<MIN>[^;]+);( -?[0-9]+):\1\2;:
    b loop_m
    :print_m
        s:;(#[^<]+<NIM>):#\1:
b redirect


#1+: <DEC>10 0 -9#label<CED> -> <DEC>9 -1 -10##label<CED>
:decr
    s:<DEC>:&;:
    :loop_d
        /<DEC>[^;]*; ?-/{
            s:(<DEC>[^;]*; ?)-([0-9]+):\1<INCp>\2#result_ip_d<pCNI>:
            b incr_pos
            :result_ip_d
                s:<INCp>([0-9]+)[^<]+<pCNI>:-\1:
            b next_d
        }
        s:(<DEC>[^;]*; ?)([0-9]+):\1<DECp>\2#result_dp_d<pCED>:
        b decr_pos
        :result_dp_d
            s:<DECp>(-?[0-9]+)[^<]+<pCED>:\1:
    :next_d
        s:(<DEC>[^;]*);( ?-?[0-9]+):\1\2;:
    /;#[^<]+<CED>/!b loop_d
    s:;(#[^<]+<CED>):#\1:
b redirect


#1+: <INC>9 0 -10 -1#label<CNI> -> <INC>10 1 -9 0##label<CNI>
:incr
    s:<INC>:&;:
    :loop_i
        /<INC>[^;]*; ?-/{
            s:(<INC>[^;]*; ?)-([0-9]+):\1<DECp>\2#result_dp_i<pCED>:
            b decr_pos
            :result_dp_i
                s:<DECp>0#[^<]+<pCED>:0:
                s:<DECp>([0-9]+)[^<]+<pCED>:-\1:
            b next_i
        }
        s:(<INC>[^;]*; ?)([0-9]+):\1<INCp>\2#result_ip_i<pCNI>:
        b incr_pos
        :result_ip_i
            s:<INCp>([0-9]+)[^<]+<pCNI>:\1:
    :next_i
        s:(<INC>[^;]*);( ?-?[0-9]+):\1\2;:
    /;#[^<]+<CNI>/!b loop_i
    s:;(#[^<]+<CNI>):#\1:
b redirect


######################### BASE LIB 2.0 #########################

#1-2: <DIVp>14 5#label<pVID> -> <DIVp>2##label<pVID>
#1-2: <DIVp>5 14#label<pVID> -> <DIVp>0##label<pVID>
#1-2: <DIVp>9 0#label<pVID> -> INFINITE RUNTIME!!
:div_pos
    #TODO: write a much simpler algorithm, which also handles /0!
    /(<DIVp>)([0-9]+)#/{
        s::\1\2 1,\2 \2#:
        b print_dvp
    }
    s:#[^<]+<pVID>:,1&:
    :loop_dvp
        s: ([0-9]+),([0-9]+)(#[^<]+<pVID>): \1,\2 <MULTp>\2 \1#result_mmp_dvp<pTLUM>\3:
        b mult_pos
        :result_mmp_dvp
            s:<MULTp>([0-9]+)[^<]+<pTLUM>:\1:
        /<DIVp>([0-9]+) [0-9]+,[0-9]+ \1#/b print_dvp
        s:(<DIVp>)([0-9]+) ([0-9]+),([0-9]+) ([0-9]+):&;<MAXp>\2 \5#result_Mp_dvp<pXAM>:
        b max_pos
        :result_Mp_dvp
            s:<MAXp>([0-9]+)[^<]+<pXAM>:\1:
        / ([0-9]+);\1#([^<]+<pVID>)/{
            s:,([0-9]+) ([0-9]+);[0-9]+(#[^<]+<pVID>):,<DECp>\1#result_dp_dvp<pCED> \2\3:
            b decr_pos
            :result_dp_dvp
                s:<DECp>([0-9]+)[^<]+<pCED>:\1:
            b print_dvp
        }
        s:,([0-9]+) [0-9]+;[0-9]+(#[^<]+<pVID>):,<INCp>\1#result_ip_dvp<pCNI>\2:
        b incr_pos
        :result_ip_dvp
            s:<INCp>([0-9]+)[^<]+<pCNI>:\1:
    b loop_dvp
    :print_dvp
        s:(<DIVp>)[0-9]+ [0-9]+,([0-9]+) [0-9]+:\1\2#:
b redirect


#1-2: <MULTp>9 14#label<pTLUM> -> <MULTp>126##label<pTLUM>
:mult_pos
	/(<MULTp>)([0-9]+)#/{
        s::\10 \2,\2:
        b print_mmp
    }
    s:#[^<]+<pTLUM>:,0&:
	:loop_mmp
        /<MULTp>0/b print_mmp
        s:(<MULTp>)([0-9]+):\1<DECp>\2#result_dp_mmp<pCED>:
        b decr_pos
        :result_dp_mmp
            s:<DECp>([0-9]+)[^<]+<pCED>:\1:
        s:(<MULTp>[0-9]+ )([0-9]+),([0-9]+):\1\2,<ADDp>\3 \2#result_ap_mmp<pDDA>:
        b add_pos
        :result_ap_mmp
            s:<ADDp>([0-9]+)[^<]+<pDDA>:\1:
    b loop_mmp
	:print_mmp
		s:(<MULTp>)0 [0-9]+,([0-9]+):\1\2#:
b redirect


#1-2: <SUBp>9 14#label<pBUS> -> <SUBp>-5##label<pBUS>
#1-2: <SUBp>14 9#label<pBUS> -> <SUBp>5##label<pBUS>
:sub_pos
    /<SUBp>[0-9]+#/b print_sp
    :loop_sp
        /<SUBp>((0 )|([0-9]+ 0))/{
            s:(<SUBp>)([0-9]+) 0:\1\2:
            s:(<SUBp>)0 ([0-9]+):\1-\2:
            b print_sp
        }
        s:(<SUBp>)([0-9]+):\1<DECp>\2#result_dp_sp_1<pCED>:
        b decr_pos
        :result_dp_sp_1
            s:<DECp>([0-9]+)[^<]+<pCED>:\1:
        s:(<SUBp>[0-9]+ )([0-9]+):\1<DECp>\2#result_dp_sp_2<pCED>:
        b decr_pos
        :result_dp_sp_2
            s:<DECp>([0-9]+)[^<]+<pCED>:\1:
    b loop_sp
    :print_sp
        s:#[^<]+<pBUS>:#&:
b redirect


#1-2: <ADDp>9 14#label<pDDA> -> <ADDp>23##label<pDDA>
:add_pos
    /<ADDp>[0-9]+#/b print_ap
    :loop_ap
        /<ADDp>0/{
            s:(<ADDp>)0 :\1:
            b print_ap
        }
        s:(<ADDp>)([0-9]+):\1<DECp>\2#result_dp_ap<pCED>:
        b decr_pos
        :result_dp_ap
            s:<DECp>([0-9]+)[^<]+<pCED>:\1:
        s:(<ADDp>[0-9]+ )([0-9]+):\1<INCp>\2#result_ip_ap<pCNI>:
        b incr_pos
        :result_ip_ap
            s:<INCp>([0-9]+)[^<]+<pCNI>:\1:
    b loop_ap
    :print_ap
        s:#[^<]+<pDDA>:#&:
b redirect


#1-2: <MAXp>110 34#label<pXAM> -> <MAXp>110##label<pXAM>
:max_pos
    /(<MAXp>)([0-9]+)#/{
        s::\1A\2,0B\2,0M\2#:
        b print_Mp
    }
    s:(<MAXp>)([0-9]+) ([0-9]+):\1A\2,\2B\3,\3M\3:
    :loop_Mp
        /,0[BM][^<]+<pXAM>/{
            s:(<MAXp>)A([0-9]+),[1-9][0-9]*B[0-9]+,0M[0-9]+:\1A0,0B0,0M\2:
            b print_Mp
        }
        s:,([0-9]+)(B[^<]+<pXAM>):,<DECp>\1#result_dp_Mp_1<pCED>\2:
        b decr_pos
        :result_dp_Mp_1
            s:,<DECp>([0-9]+)#[^<]+<pCED>(B[^<]+<pXAM>):,\1\2:
        s:,([0-9]+)(M[^<]+<pXAM>):,<DECp>\1#result_dp_Mp_2<pCED>\2:
        b decr_pos
        :result_dp_Mp_2
            s:,<DECp>([0-9]+)#[^<]+<pCED>(M[^<]+<pXAM>):,\1\2:
    b loop_Mp
    :print_Mp
        s:(<MAXp>)A[0-9]+,[0-9]+B[0-9]+,[0-9]+M([0-9]+):\1\2:
        s:#[^<]+<pXAM>:#&:
b redirect


#1-2: <MINp>110 34#label<pNIM> -> <MINp>34##label<pNIM>
:min_pos
    /(<MINp>)([0-9]+)#/{
        s::\1A\2,0B\2,0m\2#:
        b print_mp
    }
    s:(<MINp>)([0-9]+) ([0-9]+):\1A\2,\2B\3,\3m\3:
    :loop_mp
        /,0[Bm][^<]+<pNIM>/{
            s:(<MINp>)A([0-9]+),0B[0-9]+,[1-9][0-9]*m[0-9]+:\1A0,0B0,0m\2:
            b print_mp
        }
        s:,([0-9]+)(B[^<]+<pNIM>):,<DECp>\1#result_dp_mp_1<pCED>\2:
        b decr_pos
        :result_dp_mp_1
            s:,<DECp>([0-9]+)#[^<]+<pCED>(B[^<]+<pNIM>):,\1\2:
        s:,([0-9]+)(m[^<]+<pNIM>):,<DECp>\1#result_dp_mp_2<pCED>\2:
        b decr_pos
        :result_dp_mp_2
            s:,<DECp>([0-9]+)#[^<]+<pCED>(m[^<]+<pNIM>):,\1\2:
    b loop_mp
    :print_mp
        s:(<MINp>)A[0-9]+,[0-9]+B[0-9]+,[0-9]+m([0-9]+):\1\2:
        s:#[^<]+<pNIM>:#&:
b redirect


#1: <DECp>10#label<pCED> -> <DECp>9##label<pCED>
#1: <DECp>0#label<pCED> -> <DECp>-1##label<pCED>
:decr_pos
	:zeros_dp
		s:0(@*)(#[^<]+<pCED>):@\1\2:
	t zeros_dp
	s:9(@*)(#[^<]+<pCED>):8\1\2:;t print_dp
	s:8(@*)(#[^<]+<pCED>):7\1\2:;t print_dp
	s:7(@*)(#[^<]+<pCED>):6\1\2:;t print_dp
	s:6(@*)(#[^<]+<pCED>):5\1\2:;t print_dp
	s:5(@*)(#[^<]+<pCED>):4\1\2:;t print_dp
	s:4(@*)(#[^<]+<pCED>):3\1\2:;t print_dp
	s:3(@*)(#[^<]+<pCED>):2\1\2:;t print_dp
	s:2(@*)(#[^<]+<pCED>):1\1\2:;t print_dp
	s:1(@*)(#[^<]+<pCED>):0\1\2:;t print_dp
	:print_dp
        s:(<DECp>)@#:\1-1#:
		s:(<DECp>)0@:\1@:
		:loop_dp
			s:(<DECp>[^#]*)@:\19:
		/<DECp>[^#]*@/b loop_dp
		s:#[^<]+<pCED>:#&:
b redirect


#1: <INCp>9#label<pCNI> -> <INCp>10##label<pCNI>
:incr_pos
	:nines_ip
		s:9(@*)(#[^<]+<pCNI>):@\1\2:
	t nines_ip
	s:0(@*)(#[^<]+<pCNI>):1\1\2:;t print_ip
	s:1(@*)(#[^<]+<pCNI>):2\1\2:;t print_ip
	s:2(@*)(#[^<]+<pCNI>):3\1\2:;t print_ip
	s:3(@*)(#[^<]+<pCNI>):4\1\2:;t print_ip
	s:4(@*)(#[^<]+<pCNI>):5\1\2:;t print_ip
	s:5(@*)(#[^<]+<pCNI>):6\1\2:;t print_ip
	s:6(@*)(#[^<]+<pCNI>):7\1\2:;t print_ip
	s:7(@*)(#[^<]+<pCNI>):8\1\2:;t print_ip
	s:8(@*)(#[^<]+<pCNI>):9\1\2:;t print_ip
	:print_ip
		s:(<INCp>)@:\11@:
		:loop_ip
			s:(<INCp>[^#]*)@:\10:
		/<INCp>[^#]*@/b loop_ip
		s:#[^<]+<pCNI>:#&:
b redirect


######################### FUNCTION GLUE #########################

:redirect
    b base_lib_redirects
    :continue_redirects_1
	b math_lib_redirects
	:continue_redirects_2
	b user_redirects


:base_lib_redirects
    /##result_dp_mp_1<pCED>/b result_dp_mp_1
    /##result_dp_mp_2<pCED>/b result_dp_mp_2
    /##result_dp_Mp_1<pCED>/b result_dp_Mp_1
    /##result_dp_Mp_2<pCED>/b result_dp_Mp_2
    /##result_dp_ap<pCED>/b result_dp_ap
    /##result_ip_ap<pCNI>/b result_ip_ap
    /##result_dp_sp_1<pCED>/b result_dp_sp_1
    /##result_dp_sp_2<pCED>/b result_dp_sp_2
    /##result_dp_mmp<pCED>/b result_dp_mmp
    /##result_ap_mmp<pDDA>/b result_ap_mmp
    /##result_mmp_dvp<pTLUM>/b result_mmp_dvp
    /##result_Mp_dvp<pXAM>/b result_Mp_dvp
    /##result_dp_dvp<pCED>/b result_dp_dvp
    /##result_ip_dvp<pCNI>/b result_ip_dvp
b continue_redirects_1


:math_lib_redirects
    /##result_dp_i<pCED>/b result_dp_i
	/##result_ip_i<pCNI>/b result_ip_i
	/##result_ip_d<pCNI>/b result_ip_d
	/##result_dp_d<pCED>/b result_dp_d
    /##result_Mp_m<pXAM>/b result_Mp_m
	/##result_mp_m<pNIM>/b result_mp_m
    /##result_mp_M<pNIM>/b result_mp_M
	/##result_Mp_M<pXAM>/b result_Mp_M
    /##result_ap_a_1<pDDA>/b result_ap_a_1
    /##result_ap_a_2<pDDA>/b result_ap_a_2
    /##result_sp_a_1<pBUS>/b result_sp_a_1
    /##result_sp_a_2<pBUS>/b result_sp_a_2
    /##result_ap_s_1<pDDA>/b result_ap_s_1
    /##result_ap_s_2<pDDA>/b result_ap_s_2
    /##result_sp_s_1<pBUS>/b result_sp_s_1
    /##result_sp_s_2<pBUS>/b result_sp_s_2
    /##result_mmp_mm_1<pTLUM>/b result_mmp_mm_1
    /##result_mmp_mm_2<pTLUM>/b result_mmp_mm_2
    /##result_mmp_mm_3<pTLUM>/b result_mmp_mm_3
    /##result_mmp_mm_4<pTLUM>/b result_mmp_mm_4
    /##result_dvp_dv_1<pVID>/b result_dvp_dv_1
    /##result_dvp_dv_2<pVID>/b result_dvp_dv_2
    /##result_dvp_dv_3<pVID>/b result_dvp_dv_3
    /##result_dvp_dv_4<pVID>/b result_dvp_dv_4
b continue_redirects_2


:EOS
:END_OF_SCRIPT
	#mainly used to skip over remaining code, when needed

2*2 + 1
2 * 2+1
9 / 1+2  -  1    /    2
0-6 * 2
4  /  1 + 1
2-4/2
-4
34
7
1 / 0
9*9*9*9
1+2*3

2*2 + 1$
2#0#*2#1#+1$
0,2#0#>*2#1#+1$
0,>4#1#+1$
0,4#1#>+1$
0,4#1#+>1$
1,4#1#>+1$
1,>5$
5

2 * 2+1$
2#1#*2#0#+1$
0,2#1#>*2#0#+1$
0,2#1#*>2#0#+1$
0,2#1#*2#0#>+1$
0,2#1#*>3$
1,2#1#>*3$
1,>6$
6

9 / 1+2  -  1    /    2$
9#1#/1#0#+2#2#-1#4#/2$
0,9#1#>/1#0#+2#2#-1#4#/2$
0,9#1#/>1#0#+2#2#-1#4#/2$
0,9#1#/1#0#>+2#2#-1#4#/2$
0,9#1#/>3#2#-1#4#/2$
0,9#1#/3#2#>-1#4#/2$
0,9#1#/3#2#->1#4#/2$
0,9#1#/3#2#-1#4#>/2$
0,9#1#/3#2#-1#4#/>2$
1,9#1#>/3#2#-1#4#/2$
1,>3#2#-1#4#/2$
1,3#2#>-1#4#/2$
1,3#2#->1#4#/2$
1,3#2#-1#4#>/2$
1,3#2#-1#4#/>2$
2,3#2#>-1#4#/2$
2,>2#4#/2$
2,2#4#>/2$
2,2#4#/>2$
3,2#4#>/2$
3,2#4#/>2$
4,2#4#>/2$
4,>1$
1

0-6 * 2$
0#0#-6#1#*2$
0,0#0#>-6#1#*2$
0,>_6#1#*2$
0,_6#1#>*2$
0,_6#1#*>2$
1,_6#1#>*2$
1,_>12$
-12

4  /  1 + 1$
4#2#/1#1#+1$
0,4#2#>/1#1#+1$
0,4#2#/>1#1#+1$
0,4#2#/1#1#>+1$
0,4#2#/1#1#+>1$
1,4#2#>/1#1#+1$
1,4#2#/>1#1#+1$
1,4#2#/1#1#>+1$
1,4#2#/>2$
2,4#2#>/2$
2,>2$
2

2-4/2$
2#0#-4#0#/2$
0,2#0#>-4#0#/2$
0,>_2#0#/2$
0,_2#0#>/2$
0,_>1$
-1

undefined

undefined

7

INFINITE RUNTIME!!

9*9*9*9$
9#0#*9#0#*9#0#*9$
0,9#0#>*9#0#*9#0#*9$
0,>81#0#*9#0#*9$
0,81#0#>*9#0#*9$
0,>729#0#*9$
0,729#0#>*9$
0,>6561$
6561

1+2*3$
1#0#+2#0#*3$
0,1#0#>+2#0#*3$
0,>3#0#*3$
0,3#0#>*3$
0,>9$
9

#!/usr/bin/sed -nrf

:_Problem
	# digital root: sum all digits in a radix until the result is a single digit
	# https://cg.esolangs.gay/37/
:_Restrictions
	# Both number and radix are given as input in base 10
	# Incredibly slow computation beyond 4 digit numbers!


b debug
:main
	b digital_root
	:return_root
	s: [0-9]+:\n:p
b EOS


#x b
:digital_root
	:loop_dr
		s:^:0,:
l
		b digit_sum
		:return_sum
l
			s:^([0-9]+),[0-9]+:\1:
		/^([0-9]+) \1$/!{
			s:.*:&<MAX>&#result_dr_Mp<XAM>:
			b max_pos
			:result_dr_Mp
				s:<MAX>([0-9]+).*:@\1:
			/ ([0-9]+)@\1$/b finished
			s:@[0-9]+::
		}
	b loop_dr
	:finished
		s:@[0-9]+::
b return_root


#0,x b -> s,x b
:digit_sum
	:loop_ds
		s:,([0-9]+) ([0-9]+):&<MOD>\1 \2#result_ds_mdp<DOM>:
		b mod_pos
		:result_ds_mdp
			s:<MOD>([0-9]+).*:;\1:
		s:^([0-9]+)(,[0-9]+ [0-9]+);([0-9]+):\1\2<ADD>\1 \3#result_ds_ap<DDA>:
		b add_pos
		:result_ds_ap
			s:^[0-9]+(,[0-9]+ [0-9]+)<ADD>([0-9]+).*:\2\1:
		b integer_division
		:return_quotient
	/,0 /!b loop_ds
b return_sum


#s,x b -> s,(x//b) b
:integer_division
	s:$:;0 0:
	:loop_id
		s: ([0-9]+);[0-9]+ ([0-9]+):&<ADD>\1 \2#result_id_ap<DDA>:
		b add_pos
		:result_id_ap
			s:(;[0-9]+ )[0-9]+<ADD>([0-9]+).*:\1\2:
		/,([0-9]+) [0-9]+;[0-9]+ \1$/!{
			s:,([0-9]+) [0-9]+;[0-9]+ ([0-9]+):&<MAX>\1 \2#result_id_Mp<XAM>:
			b max_pos
			:result_id_Mp
				s:<MAX>([0-9]+).*:@\1:
			/([0-9]+)@\1$/b done
			s:@[0-9]+::
		}
		s:;([0-9]+) [0-9]+:&<INC>\1#result_id_ip<CNI>:
		b incr_pos
		:result_id_ip
			s:;[0-9]+( [0-9]+)<INC>([0-9]+).*:;\2\1:
	b loop_id
	:done
		s:,[0-9]+( [0-9]+);([0-9]+) [0-9]+@[0-9]+:,\2\1:
b return_quotient


:user_redirects
	/##result_dr_Mp<XAM>/b result_dr_Mp
	/##result_ds_mdp<DOM>/b result_ds_mdp
	/##result_ds_ap<DDA>/b result_ds_ap
	/##result_id_ap<DDA>/b result_id_ap
	/##result_id_Mp<XAM>/b result_id_Mp
	/##result_id_ip<CNI>/b result_id_ip
b EOS


:debug
	#test if GNU extensions are supported
	1v
b main


######################### MATH / UTILS ######################### (most of it was written before cg, used as my standard library :)

#4: <LCG>seed a c m#label<GCL> -> <LCG>new_seed##label<GCL>
:lcg_pos
	s:(<LCG>)([0-9]+ [0-9]+):\1<MULT>\2#result_mpp_lcgp<TLUM>:
	b mult_pos
	:result_mpp_lcgp
		s:(<LCG>)<MULT>([0-9]+)[^<]+<TLUM>:\1\2:
	s:(<LCG>)([0-9]+) ([0-9]+):\1<ADD>\3 \2#result_ap_lcgp<DDA>:
	b add_pos
	:result_ap_lcgp
		s:(<LCG>)<ADD>([0-9]+)[^<]+<DDA>:\1\2:
	s:(<LCG>)([0-9]+ [0-9]+):\1<MOD>\2#result_mdp_lcgp<DOM>:
	b mod_pos
	:result_mdp_lcgp
		s:(<LCG>)<MOD>([0-9]+)[^<]+<DOM>:\1\2#:
b redirect


#2: <INTERSECTION>3 4 5,2 3 4 5 6 7 8#label<NOITCESRETNI> -> <INTERSECTION>1##label<NOITCESRETNI>
:intersection_pos
	s:(<INTERSECTION>)([^,]+):\1!\2 :
	:loop_isp
		/<INTERSECTION>[^!]+!,/{
			s:(<INTERSECTION>)[^#]+:\10:
			b print_isp
		}
		/<INTERSECTION>[^!]*!([0-9]+) [^,]*,[^#]*\b\1\b/{
			s:(<INTERSECTION>)[^#]+:\11:
			b print_isp
		}
		s:(<INTERSECTION>[^!]*)!([0-9]+ ):\1\2!:
	b loop_isp
	:print_isp
		s:#[^<]+<NOITCESRETNI>:#&:
b redirect


#2: <SUBSET>3 4 5,2 3 4 5 6 7 8#label<TESBUS> -> <SUBSET>1##label<TESBUS>
:subset_pos
	s:(<SUBSET>)([^,]+):\1!\2 :
	:loop_ssp
		/<SUBSET>[^!]+!,/{
			s:(<SUBSET>)[^#]+:\11:
			b print_ssp
		}
		/<SUBSET>[^!]*!([0-9]+) [^,]*,[^#]*\b\1\b/{
			s:(<SUBSET>[^!]*)!([0-9]+ ):\1\2!:
			b loop_ssp
		}
	s:(<SUBSET>)[^#]+:\10:
	:print_ssp
		s:#[^<]+<TESBUS>:#&:
b redirect


#1+: <SEQ>3-5,2-8,7-7#label<QES> -> <SEQ>3 4 5,2 3 4 5 6 7 8,7##label<QES>
:seq_pos
	s:<SEQ>:&,:
	b next_sp
	:loop_sp
		/,([0-9]+)<INC>\1#[^<]+<CNI>[^<]+<QES>/b next_sp
		b incr_pos
		:result_ip_sp
			s:(<INC>)([0-9]+)#([^<]+<CNI>)([^,#]+)([^<]+<QES>):\1\2\3\4 \2\5:
	b loop_sp
	:next_sp
		s:,[0-9]+<INC>[^<]+<CNI>([^<]+<QES>):,\1:
		/,[0-9]+-[0-9]+[,#][^<]+<QES>/!b print_sp
		s:,([0-9]+)-([0-9]+)([,#][^<]+<QES>):,\2<INC>\1#result_ip_sp<CNI>\1\3:
	b loop_sp
	:print_sp
		s:(<SEQ>),([^#]+)(#[^<]+<QES>):\1\2#\3:
b redirect


#1+: <MAX>1 2 3#label<XAM> -> <MAX>3##label<XAM>
:max_pos
	s:(<MAX>)([0-9]+#):\10 \2:
	s: ?([0-9]+) ([0-9]+)(#[^<]+<XAM>):A\1,\1B\2,\2M\2\3:
	:loop_Mp
		/,0[BM][^<]+<XAM>/b next_Mp
		s:,([0-9]+)(B[^<]+<XAM>):,<DEC>\1#result_dp_Mp1<CED>\2:
		b decr_pos
		:result_dp_Mp1
			s:,<DEC>([0-9]+)#[^<]+<CED>(B[^<]+<XAM>):,\1\2:
		s:,([0-9]+)(M[^<]+<XAM>):,<DEC>\1#result_dp_Mp2<CED>\2:
		b decr_pos
		:result_dp_Mp2
			s:,<DEC>([0-9]+)#[^<]+<CED>(M[^<]+<XAM>):,\1\2:
	b loop_Mp
	:next_Mp
		s:A([0-9]+),[1-9][0-9]*B[0-9]+,0M[0-9]+([^<]+<XAM>):A0,0B0,0M\1\2:
		/<MAX>A/b print_Mp
		s:B[0-9]+,[0-9]+M([0-9]+)([^<]+<XAM>):B\1,\1M\1\2:
		s: ?([0-9]+)A[0-9]+,[0-9]+:A\1,\1:
	b loop_Mp
	:print_Mp
		s:A[0-9]+,[0-9]+B[0-9]+,[0-9]+M([0-9]+):\1:
		s:#[^<]+<XAM>:#&:
b redirect


#1+: <MIN>1 2 3#label<NIM> -> <MIN>1##label<NIM>
:min_pos
        s:(<MIN>)([0-9]+)#:\1\20 \2#:
	s:(<MIN>0)0:\1:
        s: ?([0-9]+) ([0-9]+)(#[^<]+<NIM>):A\1,\1B\2,\2m\2\3:
        :loop_mp
                /,0[Bm][^<]+<NIM>/b next_mp
#compare lengths first before the dec method
                s:,([0-9]+)(B[^<]+<NIM>):,<DEC>\1#result_dp_mp1<CED>\2:
                b decr_pos
                :result_dp_mp1
                        s:,<DEC>([0-9]+)#[^<]+<CED>(B[^<]+<NIM>):,\1\2:
                s:,([0-9]+)(m[^<]+<NIM>):,<DEC>\1#result_dp_mp2<CED>\2:
                b decr_pos
                :result_dp_mp2
                        s:,<DEC>([0-9]+)#[^<]+<CED>(m[^<]+<NIM>):,\1\2:
        b loop_mp
        :next_mp
                s:A([0-9]+),0B[0-9]+,[1-9][0-9]*m[0-9]+([^<]+<NIM>):A0,0B0,0m\1\2:
                /<MIN>A/b print_mp
                s:B[0-9]+,[0-9]+m([0-9]+)([^<]+<NIM>):B\1,\1m\1\2:
                s: ?([0-9]+)A[0-9]+,[0-9]+:A\1,\1:
        b loop_mp
        :print_mp
                s:A[0-9]+,[0-9]+B[0-9]+,[0-9]+m([0-9]+):\1:
                s:#[^<]+<NIM>:#&:
b redirect


#2: <MOD>5 2#label<DOM> -> <MOD>1##label<DOM>
:mod_pos
	s:#[^>]+<DOM>:,0 0,0&:
	:loop_mdp_1
		s:(<MOD>[0-9]+ [0-9]+,)([0-9]+) [0-9]+,[0-9]+:\1\2 \2:
		s:(<MOD>[0-9]+ )([0-9]+),([0-9]+):\1\2,<ADD>\2 \3#result_ap_mdp<DDA>:
		b add_pos
		:result_ap_mdp
			s:<ADD>([0-9]+)[^>]+<DDA>([^>]+<DOM>):\1\2:
		s:<MOD>([0-9]+) [0-9]+,([0-9]+) [0-9]+:&<MIN>\1 \2#result_mp_mdp<NIM>:
		b min_pos
		:result_mp_mdp
			s:<MIN>([0-9]+)[^>]+<NIM>:,\1:
	/<MOD>([0-9]+) [0-9]+,[0-9]+ [0-9]+,\1/!b loop_mdp_1
	/<MOD>([0-9]+) [0-9]+,\1 / s:(<MOD>[0-9]+ [0-9]+),([0-9]+) [0-9]+:\1,\2 \2:
	s:(<MOD>[0-9]+) [0-9]+,[0-9]+ ([0-9]+),[0-9]+:\1,\2 0:
	:loop_mdp_2
		/<MOD>([0-9]+),\1/b print_mdp
		s:(<MOD>)([0-9]+):\1<DEC>\2#result_dp_mdp<CED>:
		b decr_pos
		:result_dp_mdp
			s:<DEC>([0-9]+)[^>]+<CED>:\1:
		s:(<MOD>[0-9]+,[0-9]+ )([0-9]+):\1<INC>\2#result_ip_mdp<CNI>:
		b incr_pos
		:result_ip_mdp
			s:<INC>([0-9]+)[^>]+<CNI>:\1:
	b loop_mdp_2
	:print_mdp
		s:(<MOD>)[0-9]+,[0-9]+ ([0-9]+):\1\2#:
b redirect


#1+: <MULT>2 3 4#label<TLUM> -> <MULT>24##label<TLUM>
:mult_pos
	s:(<MULT>)([0-9]+#):\11 \2:
	:loop_mpp
		/ ?\b0\b ([0-9]+)(#[^<]+<TLUM>)/{
			s:(<MULT>)[^#]+:\1 0:
			b print_mpp
		}
		s: ?([0-9]+) ([0-9]+)(#[^<]+<TLUM>):<ADD>\1 \2#result_ap_mpp<DDA>\3:
		s:(<ADD>)([0-9]+) ([^<]+<DDA>[^<]+<TLUM>):\1<SEQ>1-\2#result_sp_mpp<QES>\3:
		b seq_pos
		:result_sp_mpp
			s:(<SEQ>)[0-9]+ ?([^#]*[^<]+<QES>)([0-9]+):\3 \1\2\3:
		/<SEQ>#/!b result_sp_mpp
		s: <SEQ>[^<]+<QES>[0-9]+::
		b add_pos
		:result_ap_mpp
			s:<ADD>([^#]+)[^<]+<DDA>: \1:
	/<MULT>[0-9]+ /b loop_mpp
	:print_mpp
		s:(<MULT>) :\1:
		s:#[^<]+<TLUM>:#&:
b redirect


#1+: <ADD>1 2 3#label<DDA> -> <ADD>6##label<DDA>
:add_pos
	s:(<ADD>)([0-9]+#):\10 \2:
	s: ?([0-9]+) ([0-9]+)(#[^<]+<DDA>):<DEC>\1#result_dp_ap<CED><INC>\2#result_ip_ap<CNI>\3:
	:loop_ap
		/<DEC>0/b next_ap
		b decr_pos
		:result_dp_ap
			s:#([^<]+<CED>):\1:
		b incr_pos
		:result_ip_ap
			s:#([^<]+<CNI>):\1:
	b loop_ap
	:next_ap
		/<ADD><DEC>/b print_ap
		s: ?([0-9]+)(<DEC>)0:\2\1:
	b loop_ap
	:print_ap
		s:<DEC>0#result_dp_ap<CED><INC>([0-9]+)#result_ip_ap<CNI>(#[^<]+<DDA>):\1#\2:
b redirect


#1: <DEC>10#label<CED> -> <DEC>9##label<CED>
:decr_pos
	:zeros
		s:0(@*)(#[^<]+<CED>):@\1\2:
	t zeros
	s:9(@*)(#[^<]+<CED>):8\1\2:;t print_dp
	s:8(@*)(#[^<]+<CED>):7\1\2:;t print_dp
	s:7(@*)(#[^<]+<CED>):6\1\2:;t print_dp
	s:6(@*)(#[^<]+<CED>):5\1\2:;t print_dp
	s:5(@*)(#[^<]+<CED>):4\1\2:;t print_dp
	s:4(@*)(#[^<]+<CED>):3\1\2:;t print_dp
	s:3(@*)(#[^<]+<CED>):2\1\2:;t print_dp
	s:2(@*)(#[^<]+<CED>):1\1\2:;t print_dp
	s:1(@*)(#[^<]+<CED>):0\1\2:;t print_dp
	:print_dp
		s:(<DEC>)0@:\1@:
		:loop_dp
			s:(<DEC>[^#]*)@:\19:
		/<DEC>[^#]*@/b loop_dp
		s:#[^<]+<CED>:#&:
b redirect


#1: <INC>9#label<CNI> -> <INC>10##label<CNI>
:incr_pos
	:nines
		s:9(@*)(#[^<]+<CNI>):@\1\2:
	t nines
	s:0(@*)(#[^<]+<CNI>):1\1\2:;t print_ip
	s:1(@*)(#[^<]+<CNI>):2\1\2:;t print_ip
	s:2(@*)(#[^<]+<CNI>):3\1\2:;t print_ip
	s:3(@*)(#[^<]+<CNI>):4\1\2:;t print_ip
	s:4(@*)(#[^<]+<CNI>):5\1\2:;t print_ip
	s:5(@*)(#[^<]+<CNI>):6\1\2:;t print_ip
	s:6(@*)(#[^<]+<CNI>):7\1\2:;t print_ip
	s:7(@*)(#[^<]+<CNI>):8\1\2:;t print_ip
	s:8(@*)(#[^<]+<CNI>):9\1\2:;t print_ip
	:print_ip
		s:(<INC>)@:\11@:
		:loop_ip
			s:(<INC>[^#]*)@:\10:
		/<INC>[^#]*@/b loop_ip
		s:#[^<]+<CNI>:#&:
b redirect


:redirect
	b library_redirects
	:continue_redirects
	b user_redirects


:library_redirects
	/##result_mpp_lcgp<TLUM>/b result_mpp_lcgp
	/##result_ap_lcgp<DDA>/b result_ap_lcgp
	/##result_mdp_lcgp<DOM>/b result_mdp_lcgp
	/##result_dp_ap<CED>/b result_dp_ap
	/##result_dp_Mp1<CED>/b result_dp_Mp1
	/##result_dp_Mp2<CED>/b result_dp_Mp2
	/##result_dp_mp1<CED>/b result_dp_mp1
	/##result_dp_mp2<CED>/b result_dp_mp2
	/##result_ap_mdp<DDA>/b result_ap_mdp
	/##result_mp_mdp<NIM>/b result_mp_mdp
	/##result_dp_mdp<CED>/b result_dp_mdp
	/##result_ip_mdp<CNI>/b result_ip_mdp
	/##result_sp_mpp<QES>/b result_sp_mpp
	/##result_ap_mpp<DDA>/b result_ap_mpp
	/##result_ip_ap<CNI>/b result_ip_ap
	/##result_ip_sp<CNI>/b result_ip_sp
b continue_redirects


:EOS
	#End Of Script (mainly used to skip over remaining code, when needed)

7 10
13 16
48 10
103 2
3110 12

#!/usr/bin/sed -nrsf

:_Problem
	# sokoban derivative (only the physics system)
	# https://cg.esolangs.gay/35/
:_Restrictions
	# Tile values are only in [0-9] range and board size is fixed at 6x6.


:main
	#test if GNU extensions are supported
	1v

	#store input data, then parse the moves (first line) and the board (remaining 6 lines)
	H
	1{
		/[WASD]/!{
			s/.*/Error: no moves, [WASD]+, found on line 1!/
			p;q
		}
	}
	2,${
		/^(-?[0-9][ \t]*){6}$/!{
			s/.*/Error: board size must be 6x6, with each tile having a value in [0-9] range!/
			p;q
		}
	}
	$!d
	g
	s:^\n[^\n]+::
	/(\n[^\n]+){6}/!{
		s/.*/Error: board size must be 6x6!/
		p;q
	}
	s:[0-9 \t\n]::g
	/^-$/!{
		s/.*/Error: exactly one tile, the player, must have its value prepended with '-' (negative value)!/
		p;q
	}
	x
	s: ::g

	#print input state
	s/^\n/\nInput state:\n()/p
	s:^\n[^\n]+\n\(\)::
	x

	s/.*/Intermediary states:/p
	:loop
		g
		#call one_move, save resulting state, then discard the move
		b one_move
		:return
			h;x
			s:^[WASD]::
			x
		#print intermediary state (skip if output state reached) and loop again if needed
		s:^[WASD]:(&):
		/^\([WASD]\)\n/!p
	/^\([WASD]\)\n/!b loop

	#print output state
	s/^/Output state:\n/p
b EOS


:one_move
	#index the board
	s:\n(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])\n:\n,0=\1,1=\2,2=\3,3=\4,4=\5,5=\6\n@:
	s:@(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])\n:,6=\1,7=\2,8=\3,9=\4,10=\5,11=\6\n@:
	s:@(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])\n:,12=\1,13=\2,14=\3,15=\4,16=\5,17=\6\n@:
	s:@(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])\n:,18=\1,19=\2,20=\3,21=\4,22=\5,23=\6\n@:
	s:@(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])\n:,24=\1,25=\2,26=\3,27=\4,28=\5,29=\6\n@:
	s:@(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9])(-?[0-9]):,30=\1,31=\2,32=\3,33=\4,34=\5,35=\6:

	#setup number line and the tile adjacency table (lazy to calculate it)
        s:$:\nL0112233445566778899L:
	s:-([0-9])(.*L[0-9]+)\1\1:-\1\2\1-\1:
	s:$:<ADJ>,0-S6D1,1-S7A0D2,2-S8A1D3,3-S9A2D4,4-S10A3D5,5-S11A4:
	s:$:,6-W0S12D7,7-W1S13A6D8,8-W2S14A7D9,9-W3S15A8D10,10-W4S16A9D11,11-W5S17A10:
	s:$:,12-W6S18D13,13-W7S19A12D14,14-W8S20A13D15,15-W9S21A14D16,16-W10S22A15D17,17-W11S23A16:
	s:$:,18-W12S24D19,19-W13S25A18D20,20-W14S26A19D21,21-W15S27A20D22,22-W16S28A21D23,23-W17S29A22:
	s:$:,24-W18S30D25,25-W19S31A24D26,26-W20S32A25D27,27-W21S33A26D28,28-W22S34A27D29,29-W23S35A28:
	s:$:,30-W24D31,31-W25A30D32,32-W26A31D33,33-W27A32D34,34-W28A33D35,35-W29A34,<JDA>:

	#skip current move since player is already at the edge of the board
	/^([WASD]).*,([0-9][0-9]?)=-.*<ADJ>.*,\2-[^,]*\1/!{
		s/^[WASD]/Warning: current move & is skipped since the player is already at the edge of the board!\n&/
		P
		b skip
	}

	s:=-:=+-:
	:construct_path
		#from current player/box get the next tile in direction of current move
		s:^([WASD])(.*,)([0-9][0-9]?)(=\+.*<ADJ>.*,)\3(-[^,]*)\1([0-9][0-9]?):\6\n&:
		s:=\+:=@:
		#if next tile is an empty space, the path of tiles to move was finished, call apply_move
		/^([0-9][0-9]?)\n.*,\1=0/b apply_move
		#if next tile is a wall, skip current move
		/^([0-9][0-9]?)\n.*,\1=([0-9]).*L[0-9]+\2[0-9]*-/!{
			s/^[^\n]+\n([WASD])/Warning: current move \1 is skipped because of a blocking wall!\n\1/
			P
			b skip
		}
		#next tile is a box, mark it with + to become new current box from now on
		s:^([0-9][0-9]?)(\n.*,)\1=([0-9])(.*L[0-9]+)\3([0-9]*-):\1\2\1=+\3\4\3\5:
		s:^[^\n]+\n::
		#skip current move since current box is already at the edge of the board
		/^([WASD]).*,([0-9][0-9]?)=\+.*<ADJ>.*,\2-[^,]*\1/!{
			s/^[WASD]/Warning: current move & is skipped since last moveable box is already at the edge of the board!\n&/
			P
			b skip
		}
	b construct_path

	:apply_move
		#transform current move into opposite move, to go from empty space back to player
		s:\n[WASD]:& ,W->S,S->W,A->D,D->A :
		s:\n([WASD]) [^\n]*,\1->([WASD])[^\n]* :\n\2\n\1:

		:shift
			#call skip to finish, if current tile is already at the edge of the board
			/^([0-9][0-9]?)\n([WASD]).*<ADJ>.*,\1-[^,]*\2/!{
				s:^[^\n]+\n::
				b skip
			}
			#from current tile get the next tile in opposite direction of current move
			s:^([0-9][0-9]?)\n([WASD])(.*<ADJ>.*,)\1(-[^,]*)\2([0-9][0-9]?):\1 \5\n\2\3\1\4\2\5:
			#if next tile isn't marked with @, path was already shifted, call skip to finish
			/^[0-9][0-9]? ([0-9][0-9]?)\n.*,\1=@/!{
				s:^[^\n]+\n::
				b skip
			}
			#swap values of current tile and next tile, with next tile to become new current tile
			s:^([0-9][0-9]?) ([0-9][0-9]?)(\n.*,)\1=0(.*,)\2=(@-?[0-9]):\2\3\1=\5\4\2=0:
			s:^([0-9][0-9]?) ([0-9][0-9]?)(\n.*,)\2=(@-?[0-9])(.*,)\1=0:\2\3\2=0\5\1=\4:
		b shift

	:skip
		s:^[^\n]+\n::
		#strip tile markings
		s:=@:=:g
		s:=\+:=:g
		#remove the number line and the tile adjacency table, then strip the board index (for pretty printing back in main)
		s:\nL.*$::
		s:,[0-9][0-9]?=::g
b return


:EOS
	#End Of Script (mainly used to skip over remaining code, when needed)