taswelll's stats

#!/bin/awk /aw -ec/{system("stty raw -echo;k "ARGV[1]" $(stty size) "ARGV[2]";stty sane")}
(h;w):.'2#x; t:(~#:){,""}/0:fd:<`$fn:$[2=#x;`argv 1;x 2] /height;width, t:text(lines)
fcur:cur:scr:0 0; sel:0N 0N; clip:,"" /(fake)cursor, scroll, first selected, clipboard
CS:0x1b5b; CL:CS/" "\" H 2J"; (LI;TX;SE;BO):CS,/:" "\"37;100m 97;40m 90;47m 44m" /colors
foot:foot0:"^F Find Next  ^XCV Clipboard  ^E Eval  ^S Save  ^Q Quit" /footer
place:{[pos;str;a] $[~(0;h-1)'n:*pos-scr; a[n]:?[a[n];0|(w-4)&(pos-scr)1;str];]; a}
disp:{r:4$(4>#:)(4$-3$)//:$'1+no:scr[0]+!# m:(w-4)$scr[1]_/:((h-1)&#a)#a:scr[0]_t
 $[^*sel;s:!0;[(sa;sz):s:x@<x:(sel;cur); m:place[sa;SE]place[sz;TX]m]] /display selection
 `1:CL; `0:LI,/:r,'(TX;SE)[~(*'s)'no-1],'m,\:"\r"; f:"editing ",fn," at ",":"/$'1+cur
 `1:BO,(f,(-w-#f)$foot),CS,(";"/$'1 5+cur-scr),"H"} /r:ruler, m:main
read:{(sa;sz):sord`;$[^*sel;,t[*cur]; ~*sz-sa; ,(sz-sa)[1]#sa[1]_t[*sa] /selected lines
                      (,sa[1]_t[*sa]),((*sz-1+sa)#(1+*sa)_t),,sz[1]#t[*sz]]}
type:{(sa;sz):sord`;a:$[2>#x;,(sa[1]#t[*sa])    ,(    *x)       ,sz[1]_t@*sz /write lines
                            (,(sa[1]#t[*sa]),*x),(-1_1_x),,(*|x),sz[1]_t@*sz]
 t:: ?[t;(*sa;1+*sz);a]; desel (sa[0]+-1+#x;(sa[1]*2>#x)+#*|x)}; end:{l,#t@l:-1+#t};
sord:{a@<a:(cur^'sel;cur)}; desel:{sel::0N 0N;x}; up:{x*~0>*x}; dn:{~x[0]<#t}end/; /^v oob
sft:{ac[y]:{[f;x] $[x;;sel::cur];f 0}ac x}; scroll:{scr[0]:((#t)--2!h)&0|x+*scr;cur+x,0}
ac:(,"")!,0N; other:{[x;s] type@,(~0x1f<*x)`k/x}; /ac[key][selected?]>new cur, otherwise
ac[CS,"A"]:{x desel/up fcur-1 0}; ac[CS,"B"]:{x desel/dn fcur+1 0} /Up Down
ac[CS,"C"]:{{x[1]>#t@*x}{dn(1+*x;0)}/cur+0 1},{desel sord[] 1}     /Right
ac[CS,"D"]:{{0>x 1}{up a,#t@a:-1+*x}/cur-0 1},{desel sord[] 0}     /Left
ac[,0x13]:{fd 1:"\n"/t;>fd;fd::<`$fn;cur}; ac[,0x11]:{>fd;`1:CS,"0m",CL;`exit 0} /^S ^Q
ac[,0x05]:{$[x;type;{t::?[t;1+*cur;x];cur}]@"\n"\(~`C=@:)`k/.[.:;,"\n"/read`;::]} /^E
sprd:{t::@[t;&&(1--)\*'sord`;x]};ac[,"\t"]:{sprd@,[tw#" ";];$[x;sel+:0,tw;];cur+0,tw} /Tab
ac[CS,"Z"]:{sprd{(tw&+/&\x=" ")_x};$[x;sel::0|sel-0,tw;];0|cur-0,tw}; tw:4 /Sft+Tab, width
ac[,0x06]:{lb:&"\n"=tf:"\n"/t;m:(#a:"\n"/aa:read`)(a~)':tf; c:2+sa[1]+lb@-1+*sa:*sord` /^F
 c:c-lb@l:lb'c:$[^n:*&c_m;*&m;c+n];foot::"found ",$+/m;sel::1 -1+l,c;(l+#aa;0|c+-1+#*|aa)}
bs:{$[~+/(l;c):cur;0 0; ~c;[a:(l-1;#t l-1);t[l-1],:t[l];t_:l;a];[t[l]_:c-1;l,c-1]]} /Back
ac[,0x08]:ac[,0x7f]:bs,del:{type@,""};ac[,0x07]:{dn(-1+.,/-1_(|/~"A0"'){1:`}\"0";0)} /^G
ac[CS,"3~"]:{(l;c):cur;:[cur~end`;; c=#t@l;[t[l],:t[l+1];t_:l+1]; t[l]_:c];cur},del /Del
ac[CS,"H"]:{(l;c):cur;l,x*~c=x:+/&\" "=t l};ac[CS,"F"]:{x desel/cur[0],#t cur 0} /Home End
ac[CS,"1;5H"]:{0 0}; ac[CS,"1;5F"]:end; ac[,0x1b]:{desel`;cur}           /^Home ^End Esc
ac[CS,"5~"]:{up x desel/scroll@-h};ac[CS,"6~"]:{dn x desel/scroll h}     /PgUp PgDn
ac[CS,"1;5A"]:{up x desel/scroll -1};ac[CS,"1;5B"]:{dn x desel/scroll 1} /^Up ^Down
wc:,/`c$"0A_a"+!'10 26 1 26; wd:{a 0 1+(a:&^wc?t@*cur)'x} / wc:word chars. v ^Left ^Right
ac[CS,"1;5C"]:{cur[0],(#t@*cur)^wd[cur 1]1}; ac[CS,"1;5D"]:{cur[0],1+-1^wd[-2+cur 1]0}
ac[,"\r"]:{type("";(&\" "=)#t@*cur)};ac[,0x18]:{clip::read`;$[x;del`;[t_:l:*cur;l,0]]} /^X
ac[,0x03]:{clip::read`;cur};ac[,0x16]:{type clip};ac[,0x01]:{sel::0 0;end`} /^C ^V ^A
sft/'CS,/:/:{("1;",/:/:"56",\:/:x),("56",/:\:" "\"~ ;2~"),+1("1;2",)'\x}"ABCDFH" /shift+..
{1}{disp`; foot::foot0; fcur::{(other x)^ac x}[1:`][~^*sel][]; cur::{[l;c] l,c&#t@l}.fcur
 scr::cur&scr|cur-(h;w)-2 5; (cur~sel)desel/` }/`
/
needs ngn/k awk stty. usage: ./txt.k filename(optional). xterm/compatible recommended.
simple. usable. extensible. pick all three. type to a line and press Ctrl+E:
  TX:CS,"30;47m";SE:CS,"97;40m" / light mode
  foot0:"\"just do it and have fun while doing it\" - HelloBoi" / add your favorite quote
  ac[,0x0a]:{."\\eject";cur} / adds a new command in ^J
\

#!/usr/bin/env swipl
p(eo,[],[],[]).
p(D,[D|X],X,[]).
p(D,[' '|X],Z,B):-p(D,X,Z,B).
p(D,['['|X],Z,[A|As]):-p('|',X,X1,C),p(']',X1,X2,B),p(D,X2,Z,As),lo(C,B,A).
p(D,[#|X],Z,[push(N)|As]):-pl(X,X1,N,0),p(D,X1,Z,As).
p(D,[+|X],Z,[add(N) |As]):-pl(X,X1,N,1),p(D,X1,Z,As).
p(D,[A|X],Z,[A|As]):-p(D,X,Z,As).
p(X,A):-p(eo,X,[],A).

pl(X,Z,N):-pl(X,Z,N,0).
pl([+|X],Z,N,N0):-N1 is N0+1,pl(X,Z,N,N1).
pl(X,X,N,N).

lo([push(0)],_,pop).
lo([push(N)],[],pop):-N\=0.
lo([push(N)],[add(M)],aff(M)):-N\=0.
lo([push(N)],B,for(B)):-N\=0.
lo(C,B,loop(C,B)).

i([],S,S).
i([A|As],S,S2):-i(A,S,S1),i(As,S1,S2).
i(add(N),[S|Ss]+M,[T|Ss]+M):-T is S+N.
i(add(N),[]+M,[N]+M).
i(push(N),S+M,[N|S]+M).
i(pop,[_|Ss]+M,Ss+M).
i(pop,[]+M,[]+M).
i(aff(_),[ ]+M,[]+M).
i(aff(N),[B]+M,[T]+M):-T is N*B.
i(aff(N),[B,A|Ss]+M,[T|Ss]+M):-T is A+N*B.
i(for(_),[0|Ss]+M,Ss+M).
i(for(_),[]+M,[]+M).
i(for(B),[I|S]+M,Sf):-I\=0,i(B,S+M,S1+M1),I2 is I-1,i(for(B),[I2|S1]+M1,Sf).
i(loop(C,_),[]+M,Sf):-i(C,[]+M,Sf).
i(loop(C,B),[I|Ss]+M,Sf):-i(C,Ss+M,S1_+M1),(S1_=[]->[]+M1=Sf;S1_=[L|S1],
  ((I=0;L=0)->S1+M1=Sf;i(B,S1+M1,S2+M2),I2 is I-1,i(loop(C,B),[I2|S2]+M2,Sf))).
i(@,[]+M,[B]+M):-g(M,0,B).
i(@,[A|Ss]+M,[B|Ss]+M):-g(M,A,B).
i(!,[]+M,[]+M2):-i(!,[0]+M,[]+M2).
i(!,[A]+M,[]+M2):-i(!,[A,0]+M,[]+M2).
i(!,[A,B|Ss]+M,Ss+M2):-s(M,A,B,M1),!,M1=M2.
i(?,[]+M,[]+M).
i(?,[A|Ss]+M/O,[B|Ss]+M/O1):-O1 is O*(A+1),between(0,A,B).

gg(a(A),_,A).
gg(a(L,_,B),N,V):-N/\B=:=0,gg(L,N,V).
gg(a(_,R,B),N,V):-N/\B=\=0,gg(R,N,V).
ss(a(_),_,V,a(V)).
ss(a(L,R,B),N,V,a(A,R,B)):-N/\B=:=0,ss(L,N,V,A).
ss(a(L,R,B),N,V,a(L,A,B)):-N/\B=\=0,ss(R,N,V,A).
s(a(L,R,B),N,V,A):-N< B<<1,ss(a(L,R,B),N,V,A).
s(a(L,R,B),N,V,A):-N>=B<<1,B1 is B<<1,e(B,R1),s(a(a(L,R,B),R1,B1),N,V,A).
s(A/O,N,V,B/O):-s(A,N,V,B).
g(a(L,R,B),N,V):-N< B<<1,gg(a(L,R,B),N,V).
g(a(_,_,B),N,0):-N>=B<<1.
g(A/_,N,V):-g(A,N,V).

e(0,a(0)).
e(N,a(L,R,N)):-N1 is N>>1,e(N1,L),e(N1,R).

t([],[]).
t([[S|_]+_/O|X],[t(S,N)|Y]):-N is 1 rdiv O,t(X,Y).
t([[]   +_/O|X],[t(0,N)|Y]):-N is 1 rdiv O,t(X,Y).

c([t(S,A)],[A-S]).
c([t(S,A),t(S,B)|As],Z):-C is A+B,c([t(S,C)|As],Z).
c([t(S,A),t(T,B)|As],[A-S|Z]):-S\=T,c([t(T,B)|As],Z).

o([]).
o([S-A|X]):-format('~t~2f~5+% ~t~d~5+~n',[S*100,A]),o(X).

:-initialization(main,main).
main([A|_]):-
  atom_chars(A,B),p(B,C),!,%writeln(C),
  e(1,M),bagof(D,i(C,[]+M/1,D),E),!,
  t(E,F),msort(F,G),c(G,H),msort(H,I),o(I).

\ Code by Jia Tan (<https://github.com/JiaT75>)

: pop ( src u -- src' u' c ) 1- swap dup c@ swap char+ -rot ;
: shift ( src u -- src' u' ) 1- swap char+ swap ;

: peek ( src u -- src u c ) over c@ ;
: ?peek ( src u -- src u c ) dup if peek else -1 then ;

: skip-'\' ( src u c -- src u c )
	dup '\' = if drop pop then
;

defer parenthesis
: terminal ( src u -- src u unrch? )
	pop 
	dup '(' = if drop parenthesis else
	dup '[' = if drop shift -1 else
		skip-'\' c, 0 then then
;
: kleene ( src u unrch? -- src u unrch? )
	third c@ '*' = if drop shift 0 then
;

: not-ending? ( src u -- src u continue? )
	dup if peek dup '|' <> swap ')' <> and else 0 then
;
: alternative ( src u -- src u unrch? )
	0 >r begin not-ending? while
		terminal kleene r> or >r
	repeat r>
;

: find-candidate ( src u -- start src u unrch? )
	here -rot  ( keep in stack, in case we need to restore )
	begin
		alternative while ( break if reachable )
		third ->here ( restore string )
		?peek '|' = if shift else -1 exit then
	repeat 0
;
: paren-depth ( c n -- n' )
	over '(' = if 1+ else over ')' = if 1- then then nip
;
: skip-until-')' ( src u -- src' u' )
	1 >r begin 
		dup 0= if exit then ( quit if empty )
		pop skip-'\' r> paren-depth dup >r while
	repeat rdrop
;

:noname ( src u -- src u unrch? )
	find-candidate >r rot drop skip-until-')' r>
; is parenthesis

: recover ( start -- str u ) here over - [ 1 chars ] literal / ;
: generate ( src u -- str u unrch? )
	find-candidate >r 2drop recover r>
;
: deallot ( src u -- ) chars negate allot drop ;
: main ( -- )
	generate if ." *unreachable*" else 2dup type cr then deallot
;

next-arg main bye

( devices )
|00 @System [ &vector $2 &pad $6 &r $2 &g $2 &b $2 &debug $1 ]
|10 @Console [ &vector $2 &read $1 &pad $4 &type $1 &write $1 &error $1 ]
|20 @Screen [ &vector $2 &width $2 &height $2 &pad $2 &x $2 &y $2 &addr $2 &pixel $1 &sprite $1 ]
|90 @Mouse [ &vector $2 &x $2 &y $2 &state $1 &pad $7 &scrolly $1 ]

|00 @pressed $1 @shape $2
%BLIT { .Screen/y DEO2 .Screen/x DEO2 #42 .Screen/pixel DEO }

%ABS2 { DUP2k #1f SFT2 MUL2 SUB2 }
%NOT { #01 EOR }
%NEG { #ff MUL }
%NEG2 { #ffff MUL2 }

%DBG { #01 .System/debug DEO }
%ISNEG2 { #0f SFT2 NIP }
%ISPOS2 { POP #80 LTH }
%DBL2 { #10 SFT2 }
%SGN2 { #1f SFT2 #0001 SWP2 SUB2 }

|0100
	#0f7f .System/r DEO2
	#0fd6 .System/g DEO2
	#0fb2 .System/b DEO2
	( .Screen/width DEO2 )
	#00 .pressed STZ
	;shapes .shape STZ2
	
	;on-mouse .Mouse/vector DEO2

@on-mouse ( -> )
	#0000 DUP2 .Screen/y DEO2 .Screen/x DEO2 #c0 .Screen/pixel DEO
	.Mouse/state DEI #01 AND DUP NOT ?&nopress 
		.pressed LDZ ?&nopress
		.shape LDZ2 INC2 INC2 INC2 LDA2k
		#0000 NEQ2 ?&noreset POP2 ;shapes &noreset
		.shape STZ2
	&nopress .pressed STZ
	.Mouse/x DEI2 #20 SFT2 display
	BRK

@smul21 ( x* y* -- x.y* )
	STH2 DUP2 SGN2 DUP2 ROT2 MUL2 ( xs* |x|* | y* )
	STH2r DUP2 SGN2 DUP2 ROT2 MUL2 ( xs* |x|* ys* |y|* )
	ROT2 SWP2 mul21 [ STH2 MUL2 STH2r ] MUL2 ( ys.xs.|x|.|y|* ) 
JMP2r

@mul21 ( x* y* -- x.y* )
	( OVR #80 LTH  ?&pos NEG2 mul21 JMP2r &pos )
	ROT #00 SWP ( OVR ,&meow STR ) OVR2 MUL2 ( xh y* xl.y* )
	POP STH ( xh y* | xl.y>>8 )
	ROT #00 SWP  [ MUL2 #00 STHr ] ADD2
JMP2r
%LTS2 { #8000 STH2k ADD2 SWP2 STH2r ADD2 GTH2 }
%GTS2 { #8000 STH2k ADD2 SWP2 STH2r ADD2 LTH2 }
%PI/2 { #0192 } %PI { #0324 } %2.PI { #0648 } %nPI/2 { #fe6d }
( 0x1234 0x5678 )
@cos ( x* -- cos* )
	DUP2 nPI/2 GTS2 ?&noadd 2.PI ADD2 !cos &noadd
	DUP2 PI/2 LTS2 ?&noneg PI SUB2 /noadd NEG2 JMP2r &noneg
	ABS2 DUP2 mul21 #01 SFT2 ( x^2/2* )
	DUP2k mul21 #0028 ( ~1/6 ) mul21 ( x^2/2* x^4/24* )
	SUB2 #0100 SWP2 SUB2
JMP2r
@sin ( x* -- cos* ) PI/2 SUB2 cos JMP2r

@rotate ( x* y* phi* -- x'* y'* )
	DUP2 sin STH2 cos STH2 SWP2k  ( x y y x | sin cos )
	STH2kr SWP2r smul21 SWP2 STH2kr smul21 ADD2 ( x y y.cos+x.sin | cos sin )
	STH2r STH2r ROT2 STH2 ROT2 ( x cos sin y | y.cos+x.sin )
	smul21 STH2 smul21 STH2r SWP2 SUB2 ( x.cos-y.sin | y.cos+x.sin )
	STH2r
JMP2r

%V3 { #01bb }
@project ( x* y* z* -- x'* y'* )
	STH2 
	OVR2 V3 smul21 OVR2 V3 smul21 SUB2 ( x* y* V3.x-V3.y | z* )
	ROT2 ROT2 ADD2 STH2r DBL2 SUB2 ( V3.x-V3.y x+y-2.z )
JMP2r
@display ( phi* -- )
	STH2 .shape LDZ2 LDA2k STH2
	INC2 INC2 LDA #00 &until LTHk ?&end
		STH2r point STH2kr SWP2 STH2 ( x1* y1* phi* | phi* addr* )
		transform ( x1* y1* addr* | phi* )
		STH2r point STH2kr SWP2 STH2 ( x1* x2* y1* y2* phi* | phi* addr* )
		transform ( x1* x2* y1* y2* | phi* addr* )
		Bresenham/draw
	INC !&until &end
	POP2 POP2r POP2r
	JMP2r
@point ( addr* -- x* y* z* addr* )
	%read { LDAk #00 #50 SFT2 SWP #0020 SUB2 SWP2 INC2 }  read read read JMP2r
@transform ( x* y* z* phi* -- x* y* )
	SWP2 STH2 ( x* y* phi* | z* ) rotate STH2r project
	.Screen/height DEI2 #01 SFT2 ADD2
	[ STH2 .Screen/width DEI2 #01 SFT2 ADD2 STH2r ]
JMP2r

@shapes =&shape1 11 =&shape2 0b 00 00 ( add more! )
	&shape1
		[
		00 00 00  02 00 00
		02 00 00  02 02 00
		02 02 00  00 02 00
		00 02 00  00 00 00 ]
		[
		00 00 00  00 00 02
		00 00 02  01 00 02
		01 00 02  01 00 01
		01 00 01  02 00 01
		02 00 01  02 00 00 ]
		[
		00 02 00  00 02 02
		00 02 02  01 02 02
		01 02 02  01 02 01
		01 02 01  02 02 01
		02 02 01  02 02 00 ]
		[
		02 00 01  02 02 01
		01 00 01  01 02 01
		01 00 02  01 02 02
		00 00 02  00 02 02 ]
	&shape2
		[
		01 01 00  00 01 01
		01 01 00  02 01 01
		01 01 00  01 00 01
		01 01 00  01 02 01
		01 01 02  00 01 01
		01 01 02  02 01 01
		01 01 02  01 00 01
		01 01 02  01 02 01 ]
		[
		01 00 01  00 01 01
		01 02 01  00 01 01
		01 00 01  02 01 01
		01 02 01  02 01 01 ]

@Bresenham
&draw ( x0* y0* x1* y1* -> )
	STH2 SWP2 STH2 SWP2r ( x0* x1* | y0* y1* )
	SWP2 OVR2 SWP2r OVR2r ( x1* x0* x1* | y1* y0* y1* )
	OVR2 SUB2 OVR2r SUB2r ( x1* x0* dx* | y1* y0* dy* )
	( flip points if appropriate )
	STH2kr OVR2 ADD2 ISPOS2 ?&noflip
		NEG2 ROT2 SWP2 ( x1* x0* dx* -> x0* x1* -dx* )
		STH2r NEG2 STH2 ROT2r SWP2r ( y1* y0* dy* -> y0* y1* -dy* )
	&noflip
	LIT POPk ,&blitswap STR
	STH2kr ABS2 OVR2 SUB2 ISNEG2 ?&noswap
		( x1* x0* dx* | y1* y0* dy* )
		;&dy STA2 STH2r ,&dx STR2 NIP2 ( x0* | y1* y0* )
		STH2r STH2r ROT2 STH2 SWP2 ( y1* y0* | x0* )
		LIT SWP2 ,&blitswap STR 
	!&stopswap &noswap
		( x1* x0* dx* | y1* y0* dy* )
		,&dx STR2 STH2r ,&dy STR2 NIP2r ( x1* x0* | y0* )
	&stopswap
	( x1* x0* | y0* ) 
	,&dy LDR2 DUP2
	#1f SFT2 ( dy>>16<<1 = 2(dy<0) )
	#0001 SWP2 SUB2 ( dy<0: 1-2 = -1; dy>=0: 1-0 = 1 )
	DUP2 ,&dysgn STR2 ( sign of dy.  1 going up, -1 going down )
	MUL2 DUP2 ,&dy STR2 ( dy:=abs(dy) )
	DBL2 ,&dx LDR2 SUB2 ,&diff STR2 ( diff := 2dy - dx.  x0* | y0* )
	( loop is about to start!  x1* x* | y* ) 
	&while LTH2k ( x < x1 ) ?&ent
		STH2r OVR2 OVR2 &blitswap POPk BLIT ( x* y* )
		,&diff LDR2 #0001 SUB2 ISNEG2 ?&nosft ( x-1<0 <-> x<=0 most of the time )
			LIT2 &dysgn $2 ADD2 
			,&dy LDR2 ,&dx LDR2 SUB2 DBL2 ( x* y* 2(dy-dx) ) !&after
		&nosft
			,&dy LDR2 DBL2
		&after
		;&diff LDA2k ROT2 ADD2 SWP2 STA2 ( diff := diff+2dy )
		STH2 INC2 !&while
	&ent
	POP2r POP2 POP2 
JMP2r
&dx $2 &dy $2 &diff $2

map=:(ucp;._2~LF&=)freads'in.txt'

show=: [:echo*{"0 1 map,"0{.@":"0  NB. show matrices on top of map

NB. point down, right, up, left
'pd pr pu pl'=:p=:map e."_ 1]4 6$ucp'┐│┌┬┤├┌─└├┴┬└│┘┴├┤┘─┐┤┴┬'

assert ((0,pd)-:pu,0), (0,.pr)-:pl,.0  NB. check that lines are well connected

'c1 c2 c3 c4'=:(*"2~1=+/)turns=:(4$pr,:pl)*.2#pd,:pu NB. find possible corners
ci1=:(*+/\&.,)c1                                     NB. give id to every topleft corner

NB. find corresponding corners, gradually removing non-boxes
ci2=:(>./\ "1 ci1)*c2*(-[:>./\ @}:"1 0:,. (pl>pr)*])+/\ "1   c1   NB. top right
ci4=:(>./\    ci2)*c4*(-[:>./\ @}:   0 ,  (pu>pd)*])+/\    *ci2   NB. bot right
ci3=:(>./\."1 ci4)*c3*(-[:>./\.@}."1 0:,.~(pl<pr)*])+/\."1 *ci4   NB. bot left
ci1=:(>./\.   ci3)*c1*(-[:>./\.@}.   0 ,~ (pu<pd)*])+/\.   *ci3   NB. top left

NB. reassign IDs, now that we are sure that these are boxes (this is probably useless)
'i1 i2 i3 i4'=:(0,~.#~,ci1)(#@[|i.)ci1,ci2,ci3,:ci4

NB. check that corners match (this should always work, i think)
assert ((i1,.i2)-:&(+/)i3,.i4), (i1,i3)-:&:(+/"1)i2,i4

echo 'boxes:'
cov=: -&(+/\)|.!.0                     NB. 0 0 2 0 0 0 cov 0 0 0 0 2 0 <--> 0 0 2 2 2 0
show area=:(i1 cov i3)cov"1(i2 cov i4) NB. boxes including borders. print because pretty
inside   =:(i4 cov i2)cov"1(i3 cov i1) NB. i am very happy that this works
border   =:area-inside

assert 1>:(i1 cov&:*i3)cov"1(i2 cov&:*i4) NB. check for no box overlaps
assert -.inside*.+./turns                 NB. check that the boxes are empty
assert border>:1<+/turns                  NB. check all splits are in box borders

NB. remove boxes for pathfinding. "edges" is ed,er,eu,:el where er is "can walk from right"
sidelr=:area+(i2 cov i4)cov"1(i1 cov i3)
sideud=:area+(i3 cov i1)cov"1(i4 cov i2)
edges=:p>4$sidelr,:sideud

NB. l: starting positions of all lines with IDs. lid: map from line ID -> box no
'lid l'=:((#~*)@:,;(*+/\&.,)@:*)border*1<+/turns

echo 'lines (shown for your viewing pleasure):'
connects=:3 :0 i.0 0
while. +./,*l do. show l
    rot=.l,edges*l|.~"2 1+.0j1^i.4                  NB. rot has 5 items: original,rotated d,r,u,l
    y=.y,con=./:~@~.@-.&0"1(#~2<#@~."1),/1 2 0|:rot NB. new connections between different lines
    l=:(*[-.@e.,@con)>./rot                         NB. combine rot, removing connections
end.
/:~"1{&lid<:~.y
)
NB. check no double connections or self-connections between boxes
assert ((-:~.),[:*./~:/"1) connects
echo 'Yes'

⎕←≢⍞

BEGIN {
    print length(ARGV[1]);
}

>>,+[>+<[-],+]>-
>+
[[-]<
  [->+<
    [->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
      [->[-]>>+>+<<<]
    ]]]]]]]]<
  ]>>[>]++++++[-<++++++++>]>>
]<<<[.[-]<<<]
++++++++++.

•Show≠⊑•args

#include <stdio.h>
#include <string.h>
int main(int argc, char* argv[]) {
    if (argc < 2) {
        puts("sorry");
        return 9+10;
    }
    printf("%zd\n", strlen(argv[1]));
}

(format t "~d~%" (length (cadr *posix-argv*)))

#include <cstdlib>
#include <iostream>
#include <string>

int main(int argc, char* argv[]) {
    if (argc < 2) {
        puts("sorry");
        return 9+10;
    }
    std::string word = argv[1];
    std::cout << word.size() << std::endl;
}

import std.stdio;
int main(string[] args)
{
    writefln ("%d", args[1].length);
    return 0;
}

System.argv() |> hd |> String.length() |> IO.puts()

NEXT-ARG NIP . CR BYE

package main

import "fmt"
import "os"

func main() {
	fmt.Println(len(os.Args[1]))
}

import System.Environment (getArgs)

main :: IO ()
main = do
  a <- getArgs
  print $ length $ head a

class Length {
    public static void main(String[] args) {
        System.out.println(args[0].length());
    }
}

console.log(process.argv[2].length);

#*x

print(#arg[1])

print length $ARGV[0], "\n";

<?php
echo $_SERVER['HTTP_CONTENT_LENGTH']."\n"
?>

import sys

print(len(sys.argv[1]))

p(ARGF.argv[0].length)

fn main() {
    println!("{}", std::env::args().nth(1).expect("sorry").len());
}

object Main extends App {
  println(args(0).size)
}

echo ${#1}

const std = @import("std");

pub fn main() !void {
    var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
    const gpa = general_purpose_allocator.allocator();
    const args = try std.process.argsAlloc(gpa);
    const stdout = std.io.getStdOut().writer();
    try stdout.print("{d}\n", .{args[1].len});
}