keccak#max negate and c:prng
    2r> dup IF
	keccak#max addr dest-ivsrest$ $!len  dest-ivsrest$ c:prng
	rest+
    THEN  2drop ;

: regen-ivs-part ( new-back old-back -- )
    [: c:key@ >r dest-ivsgen kalign c:key!



	U+DO
	    I I' fix-size dup { len }
	    addr>keys >r addr>keys >r dest-ivs$ r> safe/string r> umin
	    rest-prng
	len +LOOP
	regen( ." regen-ivs-part' " dest-ivsgen kalign c:key# .nnb cr )
	r> c:key! ;] regen-sema c-section ;

    r@ @ id>addr nip 0<= IF  r@ off  THEN  rdrop ;

: fstates ( -- n )  file-state $@len cell/ ;

: fstate-off ( -- )  file-state @ 0= ?EXIT
    file-state $@ bounds ?DO  I @ .dispose  cell +LOOP
    file-state $free ;
: n2o:save-block ( back tail id -- delta )
    { id } rdata-fix file( over data-rmap .mapc:dest-raddr - >r
    id id>addr? .fs-seek 64@ #10 64rshift 64>n >r )
    id id>addr? .fs-write dup /back
    file( dup IF ." file write: "
    r> id . hex. r> hex. dup hex. residualwrite @ hex. forth:cr
    ELSE  rdrop rdrop  THEN ) ;

\ careful: must follow exactly the same logic as slurp (see below)

: n2o:spit { tail back -- }
    back tail u>= ?EXIT fstates 0= ?EXIT
    slurp( ." spit: " rdata-back@ drop data-rmap with mapc dest-raddr - endwith hex.
    write-file# ? residualwrite @ hex. forth:cr )
    tail back [: { tail back } +calc fstates 0 { states fails }
	BEGIN  back tail u<  WHILE
		back tail write-file# @ n2o:save-block dup
		IF    >blockalign +to back 0
		ELSE  drop fails 1+ residualwrite off THEN to fails
		residualwrite @ 0= IF
		    write-file# file+ blocksize @ residualwrite !  THEN
	    fails states u>= UNTIL
	THEN
	msg( ." Write end" cr ) +file
	fails states u>= IF  max/back  THEN \ if all files are done, align
    ;] file-sema c-section

    dest-head dest-back dest-size + fix-size raddr+ endwith
    residualread @ umin ;
: rdata-back@ ( -- addr u )
    \G you can write from this, also a block at a time
    data-rmap with mapc
    dest-back dest-tail fix-size raddr+ endwith
    residualwrite @ umin ;
: rdata-fix ( back tail -- addr u )
    \G you can write from this, also a block at a time
    data-rmap with mapc fix-size raddr+ endwith
    residualwrite @ umin ;
: data-tail@ ( -- addr u )
    \G you can send from this - as long as you stay block aligned
    data-map with mapc
    dest-raddr dest-tail dest-head fix-size' endwith ;

: data-head? ( -- flag )
    \G return true if there is space to read data in

    dest-timestamps over erase
    data-resend# @ swap $FF fill ;
data-class to rewind-timestamps
:noname ( o:map -- ) dest-size addr>ts
    dest-timestamps over erase ;
rdata-class to rewind-timestamps

: rewind-ts-partial ( new-back old-back addr o:map -- )
    { addr } swap addr>ts swap addr>ts U+DO
	I I' fix-tssize	{ len } addr + len erase
    len +LOOP ;
:noname ( new-back old-back o:map -- )
    2dup data-resend# @ rewind-ts-partial
    2dup dest-timestamps rewind-ts-partial
    regen-ivs-part ;