0E0P constructions

[Hippo.69]

So I took a break from the project at 1st January 2025. I was not sure what plan of building the cell shell should I choose. The division to parts which will be better to build by 0 degree salvas and which by 90 degree salvas. I have decided to make a compiller combining these directions to benefit one from the other ... then I have found "more interesting stuff to do between". My plan was to use one of the 4 spirals the shell consists of and make snarks there and build rest of the shell "around it"... because I could leave this supporting structure without it's destroyal to become part of the build pattern.

Now, just now when I have decided to return to the topic the snarkmaker appeared which is order of magnitude more efficient then building it by any of these salvas. Now I would definitely build all 4 spirals using snarkmakers as building the snarks other way would be waste of resources. So the main goal is to get targets on the spirals close to the snark intended positions, and targets close to the scorbie insertors to build them in between.

I am very happy that I made this 15 months pause.

I am currently refresshing what is the project status quo ... here is the most important part of it:

Code: Select all

--plan is to make a p1 skeleton (where the DNA s moving) with p2 SoD
--there should be light rotation symmetric shell spiral allowing fill from 4 different inputs,
--that would allow mod DNA equal phase glider to reach the construction site in S corner.
--everything is built with seed of destruction (SoD).
--building shell requires allocation of "big" empty space, to prevnt next stages to allocate again,
--we create target for future use as well.
local g = golly()
local gp = require "gplus"
local gpo = require "gplus.objects"
local gpt = require "gplus.text"
local pattern = gp.pattern
g.setrule("Life")
local startX, startY = g.getpos()
local startMag=g.getmag()
-- sizes
local DNAtimelog = 24 --27
local DNAFDlog = DNAtimelog-2
local DNAloopOctavoDist = 2^(DNAFDlog-3) // 3
local quadsize = 2^(DNAFDlog-3)--5*DNAloopOctavoDist --4096 -- to be callculated
local halfsize = 2*quadsize
local DNA_outershell_dist = 400
local innerquadsize = 2*DNAloopOctavoDist + DNA_outershell_dist -- to be choosen
local shell_lane0_dist = 48      -- 64 to be decided
local shell_lane_dist = 36       -- 64 to be decided
local shell_last_extra_dist = 28--28 -- 0 -- to be decided
local oriconstr_lane_dist = shell_lane0_dist+3*shell_lane_dist+shell_last_extra_dist+60
local constr_lane_dist = shell_lane0_dist+3*shell_lane_dist+shell_last_extra_dist+20
local input_lane0_dist = 123 -- 32 -- 64
local input_lane1_dist = 32+121 -- 64
local input_lane2_dist = 32+274 -- 64
local input_lane3_dist = 32+221 -- 64
local output_lane_dist = shell_lane0_dist+3*shell_lane_dist+shell_last_extra_dist+120
local shellSoD_presnarkDist = 13
local shell_SoD_lane = input_lane0_dist + input_lane1_dist + input_lane2_dist + input_lane3_dist + 40
local shell_SoD_lane_add = 16 
local open_kernel_lane = 419+10
local snark_delay = 22 -- includes change in cordinate system
local input_time1=4*innerquadsize-8192-4*input_lane0_dist+4*shell_lane0_dist+12*shell_lane_dist+4*shell_last_extra_dist
local input_time2=12*innerquadsize-8192-8*shell_lane0_dist-20*shell_lane_dist-4*shell_last_extra_dist+1*snark_delay-4*input_lane0_dist-4*input_lane1_dist+4*shell_lane0_dist+8*shell_lane_dist -- -570*4-2
local input_time3=20*innerquadsize-8192-16*shell_lane0_dist-32*shell_lane_dist-4*shell_last_extra_dist+2*snark_delay-4*input_lane0_dist-4*input_lane1_dist-4*input_lane2_dist+4*shell_lane0_dist+4*shell_lane_dist -- -570*4-2-(570-128)*4-2
local input_time4=28*innerquadsize-8192-24*shell_lane0_dist-36*shell_lane_dist-4*shell_last_extra_dist+3*snark_delay-4*input_lane0_dist-4*input_lane1_dist-4*input_lane2_dist-4*input_lane3_dist+4*shell_lane0_dist -- -570*4-2-(570-128)*4-2-(570-256)*4-2

-- states
local shell_state=9
local output_layer_state=9
local seed_state=13
local SoD_state=11
local SoD_glidermark_state=12
local SoD_phase=1
local active_state=5
local comment_state=4
local comment_glider_state=4

-- patterns
local snarkNES=pattern()
snarkNES.array=g.parse("13bo$11b3o$10bo$10b2o3$18b2o$19bo$19bob2o$11b2o4b3o2bo$11b2o3bo3b2o$16b4o$2b2o15bo$bobo12b3o$bo13bo$2o14b5o$20bo$18bo$18b2o!")
snarkNES=snarkNES.state(shell_state)

local tubsemisnark = gpo.eater.t(2,11,gp.rcw)+ gpo.eater.t(14,14)+ gpo.tub.t(3,4)+ gpo.block.t(11,-1)+gpo.block.t(7,16)
local boatsemisnarkwithSoD = (gpo.eater.t(2,11,gp.rcw)+ gpo.eater.t(14,14)+ gpo.boat.t(2,3)+ gpo.block.t(11,-1)+ gpo.block.t(7,16)).state(output_layer_state)
        +(gpo.block.t(-4,5)+gpo.block.t(22,22)+gpo.beehive.t(12,20)).state(SoD_state)
local semisnarksemi = gpo.block.t(6,9).state(active_state)+gpo.block.t(8,8).state(comment_state)
local semisnarkready = gpo.block.t(8,8).state(active_state)+gpo.block.t(6,9).state(comment_state)
local snarkNES_SoD1=pattern()
snarkNES_SoD1.array=g.parse("21$26b2o$26b2o!")
snarkNES_SoD1=snarkNES_SoD1[SoD_phase].state(SoD_state)

local snarkNES_withSoD1=(snarkNES+snarkNES_SoD1).t(-6,-13)

local output_snarkturn_withGsoDs=(snarkNES.t(-86,0,gp.flip_x)+snarkNES.t(-90,22,gp.swap_xy)
        +gpo.eater.t(-114,31,gp.flip_x)).state(output_layer_state)
        +gpo.glider[1].t(-123,-24,gp.flip).state(comment_glider_state)
        +(gpo.blinker[1].t(-90,51)+gpo.blinker.t(-115,0)+gpo.boat.t(-37,119)+gpo.blinker.t(-95,41)+gpo.tub.t(-108,42))[SoD_phase].state(SoD_state)

local scorbiesplitter=pattern()
scorbiesplitter.array=g.parse("46bo$46b3o$49bo$40bo7b2o$40b3o$18bo24bo$16b3o23b2o$15bo$15b2o$2o$bo$bob2o$2bo2bo$3b2o$18b2o13b2o$18b2o13b2o7$21b2obo6b2o$21b2ob3o3bobo21b2o$27bo2bo23bobo$21b2ob3o2b2o25bo$22bobo31b2o$10b2o10bobo$10b2o11bo!")
scorbiesplitter=scorbiesplitter.state(output_layer_state).t(-27,11)

local scorbiesplitter_SoD=pattern()
scorbiesplitter_SoD.array=g.parse("3o28b3o30$10b2o$9bo2bo$10b2o!")
scorbiesplitter_SoD=scorbiesplitter_SoD.t(6,-2).t(-27,11)

local scorbiesplitter_SoD=pattern()
scorbiesplitter_SoD.array=g.parse("3o28b3o30$10b2o$9bo2bo$10b2o!")
scorbiesplitter_SoD=scorbiesplitter_SoD.t(6,-2).t(-27,11)

local output_oppositeSoD_splitter=(gpo.pond+gpo.blinker[1].t(6,6))

local scorbiesplitter_withSoD = scorbiesplitter+scorbiesplitter_SoD[SoD_phase].state(SoD_state)
local scorbiesplitter_withSoDp1 = scorbiesplitter+scorbiesplitter_SoD[1+SoD_phase].state(SoD_state)

local scorbiesplitter_withSoD_andEater=scorbiesplitter_withSoD +
        gpo.eater.t(82,39).state(output_layer_state).t(-27,11)

local scorbieSE=pattern()
scorbieSE.array=g.parse("2bo$2b3o$5bo$4b2o6$24b2o$24b2o4$22b2o$22bobo$24bo$24b2o6$13b2o$13b2o$5b2o$6bo$3b3o$3bo2$4bo$3bobo$3bobo$b3ob2o$o$b3ob2o$3bob2o2$13b2o$13b2o7b2o$22bo$20bobo$20b2o4$2o$2o5$16bo$15bobo$15bobo$16bo$17b3o$19bo!")
scorbieSE=scorbieSE.state(shell_state).t(6,-17)

local scorbieSE_SoD=pattern()
scorbieSE_SoD.array=g.parse("5$6b2o$6b2o10$3o22$9bo$8bobo$8bobo$9bo21$29b3o!")
scorbieSE_SoD=scorbieSE_SoD.t(-6,-17)

local scorbieSE_SoD2=pattern()
scorbieSE_SoD2.array=g.parse("34b2o$34b2o7$34b3o9$2o$2o23$7b2o$6bobo$7bo!")
scorbieSE_SoD2=scorbieSE_SoD2.t(2,-5)

local scorbieSE_withSoD=scorbieSE+scorbieSE_SoD.state(SoD_state)
local scorbieSE_withSoDp1=scorbieSE+scorbieSE_SoD[1].state(SoD_state)
local scorbieSE_withSoD2=scorbieSE+scorbieSE_SoD2.state(SoD_state)
local scorbieSE_withSoD2p1=scorbieSE+scorbieSE_SoD2[1].state(SoD_state)

local scorbie_inputglider=pattern()
scorbie_inputglider.array=g.parse("2o$obo$o!")
scorbie_inputglider=scorbie_inputglider.state(comment_glider_state).t(25,53).t(6,-17)

local outputglider=pattern()
outputglider.array=g.parse("2bo$obo$b2o!")
outputglider=outputglider.state(comment_glider_state).t(-65,-70)

local glider_SoD=pattern()
glider_SoD.array=g.parse("bo$2bo$3o!")
glider_SoD=glider_SoD[SoD_phase].state(SoD_glidermark_state).t(-7,7)

local openkernelglider=gpo.glider[0].state(comment_glider_state).t(-open_kernel_lane+64,-open_kernel_lane-64,gp.rccw)

local positionmark=pattern()
positionmark.array=g.parse("o3bo$bobo$2bo$bobo$o3bo!")
positionmark=positionmark.state(comment_state).t(-2,-2)

local filltxt=gpt.maketext("fill","mono").state(comment_state)

local inputtxt=gpt.maketext("input","mono").state(comment_state)
local inputtime1txt=gpt.maketext(input_time1-input_time1+1024,"mono").state(comment_state)
local inputtime2txt=gpt.maketext(input_time2-input_time1+1024,"mono").state(comment_state)
local inputtime3txt=gpt.maketext(input_time3-input_time1+1024,"mono").state(comment_state)
local inputtime4txt=gpt.maketext(input_time4-input_time1+1024,"mono").state(comment_state)

local outputtxt=gpt.maketext("output","mono").state(comment_state)

local openkerneltxt=gpt.maketext(" open kernel","mono").state(comment_state)

g.setrule("Life")

local function E_shell_pattern()
 local extralanesnarkSoDsplitter=pattern()
 extralanesnarkSoDsplitter.array=g.parse("bo$obo$bobo$2bo6$6b2o$5bobo$4bobo$5bo!")
 extralanesnarkSoDsplitter=extralanesnarkSoDsplitter[SoD_phase].state(SoD_state).t(17-shellSoD_presnarkDist,-3+shellSoD_presnarkDist)

 local midlanesnarkSoDsplitter=pattern()
 midlanesnarkSoDsplitter.array=g.parse("2o$obo$b2o2$15b2o$15b2o!")
 midlanesnarkSoDsplitter=midlanesnarkSoDsplitter[SoD_phase].state(SoD_state).t(23-shell_lane_dist-shellSoD_presnarkDist,8+shell_lane_dist+shellSoD_presnarkDist)

 local firstlanesnarkSoDsplitter=(gpo.tub.t(1,14)+gpo.blinker.t(2,1))[SoD_phase].state(SoD_state).t(17-2*shell_lane_dist-shellSoD_presnarkDist,5+2*shell_lane_dist+shellSoD_presnarkDist)
 local loopSoDsplitter=(gpo.tub.t(1,14)+gpo.blinker.t(2,1,gp.rcw))[SoD_phase].state(SoD_state).t(23-2*shell_lane_dist-shellSoD_presnarkDist,11+2*shell_lane_dist+shellSoD_presnarkDist)
 local loopSoDturner=gpo.long_boat.state(SoD_state).t(148-2*shell_lane_dist-shellSoD_presnarkDist,-106+2*shell_lane_dist+shellSoD_presnarkDist,gp.rcw)

 local constructionlaneblockingeaterSoDsplitter=(gpo.tub.t(13,1)+gpo.blinker.t(0,2,gp.rcw))[SoD_phase].state(SoD_state).t(51-2*shell_lane0_dist-3*shell_lane_dist-shellSoD_presnarkDist,59+shell_lane_dist+shellSoD_presnarkDist)

 local constructionstopperSoDtuner=pattern()
 constructionstopperSoDtuner.array=g.parse("bo$obo$2o!")
 constructionstopperSoDtuner=constructionstopperSoDtuner[SoD_phase].state(SoD_state).t(-16-shell_lane0_dist-2*shell_lane_dist-shellSoD_presnarkDist,-19+shell_lane0_dist+2*shell_lane_dist+shellSoD_presnarkDist)

 local constructionstopper=pattern()
 constructionstopper.array=g.parse("2o$2o!")
 constructionstopper=constructionstopper.state(shell_state)

 local constructionstopperSoD=pattern()
 constructionstopperSoD.array=g.parse("2o$2o!")
 constructionstopperSoD=constructionstopperSoD[SoD_phase].state(SoD_state).t(-7,-4)

 local constructionstopperwithSoD=(constructionstopper+constructionstopperSoD).t(-21-constr_lane_dist,-13+constr_lane_dist)

 local constructionlaneblockingeater=gpo.eater.state(shell_state).t(58-constr_lane_dist-shell_lane0_dist-shell_lane_dist,58+constr_lane_dist-shell_lane0_dist-shell_lane_dist,gp.flip)

 local constructionarmtarget=gpo.block.t(-8-42-constr_lane_dist,10+42-constr_lane_dist)
 local constructiontarget=gpo.block.t(-8+28-constr_lane_dist,10-52-constr_lane_dist)

 local oriconstructionarmtarget=gpo.block.state(comment_state).t(1-oriconstr_lane_dist-shell_lane0_dist-3*shell_lane_dist-shell_last_extra_dist,0-oriconstr_lane_dist+shell_lane0_dist+3*shell_lane_dist+shell_last_extra_dist)

 local E=pattern()+positionmark
 E=E+filltxt.t(-6-2*shell_lane0_dist-5*shell_lane_dist-shell_last_extra_dist,15+0*shell_lane0_dist-shell_lane_dist-shell_last_extra_dist)
 E=E+filltxt.t(0-2*shell_lane0_dist-3*shell_lane_dist,15+0*shell_lane0_dist-shell_lane_dist,gp.rcw)
 E=E+filltxt.t(20-2*shell_lane0_dist-shell_lane_dist,20+0*shell_lane0_dist-shell_lane_dist,gp.flip)
 E=E +constructiontarget+constructionarmtarget
         +constructionlaneblockingeater+constructionstopperwithSoD+oriconstructionarmtarget+constructionlaneblockingeaterSoDsplitter+constructionstopperSoDtuner
 E=E+openkernelglider
 E=E+openkerneltxt.t(-open_kernel_lane+64,-open_kernel_lane-64)
 E=E+openkerneltxt.t(-open_kernel_lane+64,-open_kernel_lane-64,gp.rcw)
 E=E+openkerneltxt.t(-open_kernel_lane+64,-open_kernel_lane-64,gp.flip)
 E=E+openkerneltxt.t(-open_kernel_lane+64,-open_kernel_lane-64,gp.rccw)
 -- E=E+gpo.blinker.t(-open_kernel_lane+82,-open_kernel_lane-92,gp.rcw)+gpo.blinker.t(-open_kernel_lane+86,-open_kernel_lane-92,gp.rcw)
 --        +gpo.long_boat.t(-constr_lane_dist+93,-constr_lane_dist-89,gp.rcw) -- debug timing
 E=E+(gpo.pond.t(-8,20)+gpo.beehive.t(-4,14)+gpo.ship.t(-18,6)+gpo.block.t(-33,2)).state(SoD_state).t(-open_kernel_lane,-open_kernel_lane)
 E=E+(snarkNES_withSoD1+firstlanesnarkSoDsplitter+loopSoDsplitter+loopSoDturner).t(-2*shell_lane0_dist-shell_lane_dist,0*shell_lane0_dist-shell_lane_dist)
 E=E+(snarkNES_withSoD1+midlanesnarkSoDsplitter).t(-2*shell_lane0_dist-3*shell_lane_dist,0*shell_lane0_dist-shell_lane_dist)
 E=E+(snarkNES_withSoD1+extralanesnarkSoDsplitter
         +(gpo.pond.t(-9,21)+gpo.blinker.t(-3,27))[SoD_phase].state(SoD_state) -- destroy eater after reflector to shell construction
       ).t(-2*shell_lane0_dist-5*shell_lane_dist-shell_last_extra_dist,0*shell_lane0_dist-shell_lane_dist-shell_last_extra_dist)
 return E
end

local function SE_shell_pattern()
 local scorbie_SoD_turner=pattern()
 scorbie_SoD_turner.array=g.parse("o$o$o2$o$o$o!")
 scorbie_SoD_turner=scorbie_SoD_turner[SoD_phase].state(SoD_state).t(23,-8)

 --local SE_SoD_turner=pattern()
 --SE_SoD_turner.array=g.parse("b2o$obo$bo!")
 --SE_SoD_turner=SE_SoD_turner[SoD_phase].state(SoD_state).t(64-21,64+17)
 --local SE_SoD_spitter=pattern()
 --SE_SoD_spitter.array=g.parse("2bo$bobo$o2bo$b2o3$10b2o$9bobo$10bo!")
 --SE_SoD_spitter=SE_SoD_spitter[SoD_phase].state(SoD_state).t(64-3,64-55)

 local prescorbie_SoD_turner=pattern()
 prescorbie_SoD_turner.array=g.parse("2o$obo$bo!")
 prescorbie_SoD_turner=prescorbie_SoD_turner[SoD_phase].state(SoD_state).t(64-12,64-41)

 local SE=pattern()+positionmark
 SE=SE+(scorbieSE+scorbieSE_SoD[SoD_phase].state(SoD_state)).t(-input_lane0_dist-shell_lane0_dist-3*shell_lane_dist-shell_last_extra_dist,input_lane0_dist-shell_lane0_dist-3*shell_lane_dist-shell_last_extra_dist)
 SE=SE+scorbie_inputglider.t(-input_lane0_dist-shell_lane0_dist,input_lane0_dist-shell_lane0_dist)
 SE=SE+inputtxt.t(-2-input_lane0_dist-shell_lane0_dist,36+input_lane0_dist-shell_lane0_dist)
 SE=SE+inputtime1txt.t(-2-input_lane0_dist-shell_lane0_dist,46+input_lane0_dist-shell_lane0_dist)

 SE=SE+scorbie_SoD_turner.t(-input_lane0_dist-shell_lane0_dist-2*shell_lane_dist,input_lane0_dist-shell_lane0_dist-2*shell_lane_dist)

 SE=SE+(scorbieSE+scorbieSE_SoD[SoD_phase].state(SoD_state)).t(-input_lane0_dist-input_lane1_dist-shell_lane0_dist-2*shell_lane_dist,input_lane0_dist+input_lane1_dist-shell_lane0_dist-2*shell_lane_dist)
 SE=SE+scorbie_inputglider.t(-input_lane0_dist-input_lane1_dist-shell_lane0_dist,input_lane0_dist+input_lane1_dist-shell_lane0_dist)
 SE=SE+inputtxt.t(36-input_lane0_dist-input_lane1_dist-shell_lane0_dist,40+input_lane0_dist+input_lane1_dist-shell_lane0_dist,gp.rcw)
 SE=SE+inputtime2txt.t(26-input_lane0_dist-input_lane1_dist-shell_lane0_dist,40+input_lane0_dist+input_lane1_dist-shell_lane0_dist,gp.rcw)

 SE=SE+scorbie_SoD_turner.t(-input_lane0_dist-input_lane1_dist-shell_lane0_dist-shell_lane_dist,input_lane0_dist+input_lane1_dist-shell_lane0_dist-shell_lane_dist)

 SE=SE+(scorbieSE+scorbieSE_SoD[SoD_phase].state(SoD_state)).t(-input_lane0_dist-input_lane1_dist-input_lane2_dist-shell_lane0_dist-shell_lane_dist,input_lane0_dist+input_lane1_dist+input_lane2_dist-shell_lane0_dist-shell_lane_dist)
 SE=SE+scorbie_inputglider.t(-input_lane0_dist-input_lane1_dist-input_lane2_dist-shell_lane0_dist,input_lane0_dist+input_lane1_dist+input_lane2_dist-shell_lane0_dist)
 SE=SE+inputtxt.t(28-input_lane0_dist-input_lane1_dist-input_lane2_dist-shell_lane0_dist,40+input_lane0_dist+input_lane1_dist+input_lane2_dist-shell_lane0_dist,gp.flip)
 SE=SE+inputtime3txt.t(28-input_lane0_dist-input_lane1_dist-input_lane2_dist-shell_lane0_dist,30+input_lane0_dist+input_lane1_dist+input_lane2_dist-shell_lane0_dist,gp.flip)

 SE=SE+scorbie_SoD_turner.t(-input_lane0_dist-input_lane1_dist-input_lane2_dist-shell_lane0_dist,input_lane0_dist+input_lane1_dist+input_lane2_dist-shell_lane0_dist)

 SE=SE+(scorbieSE+scorbieSE_SoD[SoD_phase].state(SoD_state)).t(-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist,input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist)
 SE=SE+scorbie_inputglider.t(-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist,input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist)
 SE=SE+inputtxt.t(28-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist,70+input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist,gp.rccw)
 SE=SE+inputtime4txt.t(38-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist,70+input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist,gp.rccw)
 SE=SE+(gpo.loaf.t(24,52,gp.flip)+gpo.block.t(16,52)+gpo.boat.t(32,55,gp.rcw)).state(SoD_state).t(-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist,input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist)
 SE=SE+prescorbie_SoD_turner.t(-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist,input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist)


 SE=SE.t(-2*innerquadsize+2*DNAloopOctavoDist,2*innerquadsize-2*DNAloopOctavoDist)+positionmark

 SE=SE+outputglider.t(input_lane0_dist-shell_lane0_dist,-input_lane0_dist-shell_lane0_dist)
 SE=SE+outputtxt.t(-69+input_lane0_dist-shell_lane0_dist,-64-input_lane0_dist-shell_lane0_dist,gp.flip)
 SE=SE+outputglider.t(input_lane0_dist+input_lane1_dist-shell_lane0_dist,-input_lane0_dist-input_lane1_dist-shell_lane0_dist)
 SE=SE+outputtxt.t(-68+input_lane0_dist+input_lane1_dist-shell_lane0_dist,-74+-input_lane0_dist-input_lane1_dist-shell_lane0_dist,gp.rccw)
 SE=SE+outputglider.t(input_lane0_dist+input_lane1_dist+input_lane2_dist-shell_lane0_dist,-input_lane0_dist-input_lane1_dist-input_lane2_dist-shell_lane0_dist)
 SE=SE+outputtxt.t(-60+input_lane0_dist+input_lane1_dist+input_lane2_dist-shell_lane0_dist,-72-input_lane0_dist-input_lane1_dist-input_lane2_dist-shell_lane0_dist)
 SE=SE+outputglider.t(input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist,-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist)
 SE=SE+outputtxt.t(-60+input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist-shell_lane0_dist,-64-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist-shell_lane0_dist,gp.rcw)

 SE=SE.t(innerquadsize-DNAloopOctavoDist,-innerquadsize+DNAloopOctavoDist)+positionmark

 return SE
end

local function shell_corners_E_N_W_S() -- not shifted
 local E=E_shell_pattern()
 return E,E.t(0,0,gp.rccw),E.t(0,0,gp.flip),E.t(0,0,gp.rcw)
end

local function shell_sides_SE_NE_NW_SW() -- not shifted
 local SE=SE_shell_pattern()
 return SE,SE.t(0,0,gp.rccw),SE.t(0,0,gp.flip),SE.t(0,0,gp.rcw)
end

local E,N,W,S=shell_corners_E_N_W_S()
local SE,NE,NW,SW=shell_sides_SE_NE_NW_SW()

local function E_output()
 local S=13 -- NE shift of SOD
 E=E+(scorbiesplitter_withSoD
    +(gpo.boat.t(71, 45,gp.rccw)+gpo.boat.t(65, 49,gp.rccw)+gpo.boat.t(60, 44,gp.rccw) + gpo.eater.t(50,44,gp.swap_xy)).state(output_layer_state)
    +(gpo.long_boat.t(57+S,-39-S,gp.flip)+gpo.blinker.t(56+S,-33-S,gp.rcw)
     ).state(SoD_state)
    +(scorbiesplitter_withSoD
      +(gpo.tub.t(37+S,-15-S)+gpo.blinker.t(24+S,-14-S,gp.rcw)).state(SoD_state)
     ).t(90,47)
    +(snarkNES.state(output_layer_state)
      +(gpo.blinker.t(29,0)+gpo.long_boat.t(34+S,-13-S,gp.flip)+gpo.blinker.t(33+S,-7-S)
       ).state(SoD_state)
     ).t(169,118)
    +(scorbieSE
      +(gpo.blinker.t(37,3,gp.rcw)+gpo.block.t(2,12)+gpo.block.t(36,-5)+gpo.boat.t(10,36,gp.rcw)
         +gpo.blinker.t(22,-33,gp.rcw)+gpo.long_boat.t(28,-34)
         +gpo.boat.t(101+S,35+S)
       ).state(SoD_state)
     ).t(-33+170,349-170,gp.flip_y)
    +(snarkNES.state(output_layer_state)
      +(gpo.blinker.t(29,0)
         +gpo.blinker.t(89-S,-88+S,gp.rcw)+gpo.long_boat.t(95-S,-89+S)
       ).state(SoD_state)
     ).t(-44+170,331-170,gp.swap_xy_flip)
    +(gpo.eater.state(output_layer_state)+(gpo.pond.t(-16,15)+gpo.blinker.t(-10,21)).state(SoD_state)).t(137,89)  -- fill prevent and its SoD
    +(snarkNES.state(output_layer_state)
      +(gpo.block.t(26,21)+gpo.blinker.t(-29,73,gp.rcw)+gpo.tub.t(-30,86)).state(SoD_state)
     ).t(525-DNAloopOctavoDist+input_lane0_dist+input_lane1_dist+input_lane2_dist,-264+DNAloopOctavoDist-input_lane0_dist-input_lane1_dist-input_lane2_dist,gp.flip_x)
    ).t(-2*DNA_outershell_dist-6,-46)
    +(scorbieSE_withSoD2p1
      +(gpo.loaf.t(22,-20,gp.flip)+gpo.beehive.t(19,-39)+gpo.boat.t(-42,9,gp.rcw)).state(SoD_state) -- destroyal path
       +gpo.eater.t(-32,-26,gp.swap_xy_flip).state(output_layer_state) -- to block the lane not going to shell construction
     ).t(69-DNA_outershell_dist-constr_lane_dist,-65-constr_lane_dist+DNA_outershell_dist,gp.flip)
 E=E+(gpo.boat.t(-6,5)+gpo.block.t(-14,7)).state(SoD_state).t(-310-open_kernel_lane,310-open_kernel_lane)
 -- E=E+(snarkNES.t(0,0,gp.swap_xy).state(output_layer_state)
--  +scorbiesplitter_withSoD.t(-185,-144)
--  +gpo.eater.t(28,-4,gp.rccw).state(output_layer_state)
--  +gpo.glider[1].state(comment_glider_state).t(-142,-161,gp.flip_y)
--  +(gpo.block.t(21,26)+gpo.eater.t(27,25)+gpo.boat.t(37,16,gp.rccw)).state(SoD_state)).t(135,41).t(-2*output_lane_dist,0)
end

local function N_output()
 --local info=pattern()
 --info.array=g.parse("bo$b2o$obo6bo2bo2bobobobo3bobobob3ob2o2b3o$8bobobo2bobobobo3bobobobo3bobobo$8bobob2obobobobo3bob3ob3ob2o2b3o$8b3obob2o2bo2bobobobobobo3bobobo$8bobobo2bo2bo3bobo2bobob3obobob3o!")
 local S=13 -- NE shift of SOD
 N=N+(scorbiesplitter
    +(gpo.beehive.t(28,40,gp.rcw)+gpo.beehive.t(-56,47)
      +gpo.boat.t(5,41,gp.flip)+gpo.boat.t(5+56,41-61,gp.flip)+gpo.boat.t(114,42,gp.rccw)
      +gpo.blinker.t(19,43)+gpo.blinker.t(-11,45)+gpo.blinker.t(-30,22)
      +gpo.loaf.t(-62,48,gp.rccw)
     ).state(SoD_state)
    + (gpo.boat.t(50+4, -26-4,gp.rccw)
       +gpo.boat.t(71, 45,gp.rccw)+gpo.boat.t(76, 40,gp.rccw)+gpo.boat.t(81, 35,gp.rccw)+gpo.boat.t(91, 35,gp.rccw) + gpo.eater.t(55,49,gp.swap_xy)).state(output_layer_state)
    +scorbiesplitter_withSoD.t(90,47)
    +snarkNES.state(output_layer_state).t(145+6, 94+6)
     +(gpo.tub.t(166+6,120+6)+gpo.blinker.t(179+6,119+6,gp.rcw)+gpo.blinker.t(143+6,112+6,gp.rcw)+gpo.boat.t(271+6,26+6)).state(SoD_state)
    +(snarkNES.state(output_layer_state)
      +(gpo.boat.t(116,-93,gp.rccw)+gpo.long_boat.t(46-S,-36+S,gp.rccw)+gpo.blinker.t(47-S,-30+S)+gpo.blinker.t(29,0,gp.rcw)).state(SoD_state)
     ).t(6+525-DNAloopOctavoDist+input_lane0_dist+input_lane1_dist+input_lane2_dist+input_lane3_dist,
         6-264+DNAloopOctavoDist-1-input_lane0_dist-input_lane1_dist-input_lane2_dist-input_lane3_dist,gp.flip_x)
    +(gpo.eater.state(output_layer_state)+(gpo.pond.t(-16-97,14+97)+gpo.blinker.t(-10-97,20+97)).state(SoD_state)).t(137,89)  -- fill prevent and its SoD
      ).t(-46+1,2*DNA_outershell_dist+6,gp.rccw)
    +snarkNES.state(output_layer_state).t(80+constr_lane_dist-DNA_outershell_dist,56-DNA_outershell_dist-constr_lane_dist,gp.flip_x).t(0,0,gp.flip)
    +((gpo.block
      +gpo.blinker.t(19,25,gp.rcw)+gpo.blinker.t(23,25,gp.rcw)
      ).state(SoD_state) -- destroyal path+SoD
         +gpo.eater.t(-15,24,gp.flip_x).state(output_layer_state)                                        -- eater blocking lane to shell construction
     ).t(53+constr_lane_dist-DNA_outershell_dist,77-DNA_outershell_dist-constr_lane_dist).t(0,0,gp.flip)
    +((gpo.boat.t(12,-2,gp.rcw)
       +gpo.boat.t(-23,24)
      ).state(SoD_state)).t(3+149,149-444+2*DNA_outershell_dist,gp.rccw)
 N=N+((gpo.boat.t(-6,5)+gpo.block.t(-12,5)).state(SoD_state).t(-310-open_kernel_lane,310-open_kernel_lane)).t(0,0,gp.rccw)

 local N_phasedCorectingReflector=pattern()
 N_phasedCorectingReflector.array = g.parse("169bo$167b3o$166bo$156b2o8b2o$157bo$125b2o11bo18bobo$125b2o10bobo18b2o$137bobo32b2o$136b2ob3o2b2o26b2o$142bo2bo$136b2ob3o3bobo$136b2obo6b2o$172b2o$172b2o5$133b2o13b2o$133b2o13b2o25bo$118b2o53b3o$117bo2bo51bo$116bob2o52b2o$116bo$115b2o$130b2o$130bo$131b3o$133bo4$154b2o$155bo$155bobo$156b2o3$170b2o$170bobo$172bo$163b2o7b2o$163b2o7$153b2o$154bo$154bobo$155b2o4$48bo$47bobo123b2o$47bobo7b2o114bo$45b3ob2o6b2o112bobo$44bo19b2o105b2o$45b3ob2o13b2o$47bob2o4$60bo113b2o$59bobo112bo$58bo2bo93bo16bobo$59b2o9b2o83b3o14b2o$70b2o86bo$157b2o$161bo$48b2o110bobo$48b2o110bo2bo$161b2o8$4bo$3bobo56b2o$3bobo7b2o47bo$b3ob2o6b2o48b3o96b2o$o19b2o43bo96b2o$b3ob2o13b2o$3bob2o4$16bo$15bobo$14bo2bo$15b2o9b2o$26b2o3$4b2o$4b2o10$18b2o$18bo$19b3o$21bo!")
  N=N+(N_phasedCorectingReflector.state(output_layer_state)
   + (gpo.beehive.t(-1,97)+gpo.blinker.t(14,76,gp.rcw)+gpo.beehive.t(43,70)+gpo.blinker.t(58,49)  -- bondersnatches destroyal
      +gpo.blinker.t(122,0,gp.rcw)+gpo.blinker.t(179,18,gp.rcw)+gpo.blinker.t(173,46,gp.rcw)+gpo.blinker.t(137,56,gp.rcw)+gpo.blinker.t(154,60)
      +gpo.blinker.t(177,61)+gpo.blinker.t(156,84)+gpo.loaf.t(139,2,gp.flip)+gpo.block.t(152,45)    -- reflector destroyal
      +gpo.long_boat.t(93,74,gp.rccw)
      ).state(SoD_state)
  ).t(16-32-293+shell_last_extra_dist, 16+255+2*shell_lane0_dist+6*shell_lane_dist+shell_last_extra_dist)
-- N=N+((scorbieSE+scorbieSE_SoD[1+SoD_phase].state(SoD_state)).t(95,-120,gp.rcw)
-- +gpo.eater.state(output_layer_state).t(81,-134,gp.rccw)
-- +(gpo.blinker.t(91,-97)+gpo.boat.t(8,-123,gp.flip)+gpo.boat.t(52,-71,gp.rcw)).state(SoD_state)).t(0,2*output_lane_dist)
end

local function W_output()
 W=W+(scorbiesplitter_withSoDp1
    +(gpo.boat.t(39,67,gp.flip)+gpo.boat.t(65, 49,gp.rccw)).state(output_layer_state)
    +gpo.eater.t(87,103,gp.rcw).state(output_layer_state) -- loop/construction
    +(gpo.ship.t(144,-143)+gpo.blinker.t(152,-130)).state(SoD_state)
    +(scorbiesplitter_withSoDp1
      +(gpo.boat.t(133,-105,gp.rccw)+gpo.ship.t(98,-74,gp.rcw)+gpo.block.t(94,-60)+gpo.tub.t(65,-52)+gpo.blinker.t(64,-65,gp.rcw)).state(SoD_state)
     ).t(90,47) -- NW shell construction/NW ori construction .. length critical
    +(snarkNES.state(output_layer_state)
      +(gpo.blinker.t(29,0,gp.rcw)+gpo.ship.t(94,-73)+gpo.block.t(97,-59)).state(SoD_state)
     ).t(169,118)
    +(scorbiesplitter_withSoDp1
      +(gpo.tub.t(33,-11)+gpo.blinker.t(20,-10)).state(SoD_state)
     ).t(182,166,gp.rcw)
     +(snarkNES.state(output_layer_state)
      +(gpo.blinker.t(29,0)+gpo.tub.t(131,-129)+gpo.blinker.t(130,-116,gp.rcw)).state(SoD_state)
      ).t(-44+170,331-170,gp.swap_xy_flip) -- ori construction/state reading
    +gpo.eater.t(107-12,156+12,gp.rcw).state(output_layer_state) -- NW ori construction blocker
    +(gpo.loaf.t(93-12,138+12,gp.flip)+gpo.blinker.t(89-12,132+12)).state(SoD_state) -- NW ori construction start .. length critical  fill prevent and its SoD
    +(snarkNES.state(output_layer_state)
      +(gpo.block.t(26,21)+gpo.ship.t(-36,88)+gpo.block.t(-22,91)).state(SoD_state)
     ).t(525-DNAloopOctavoDist+input_lane0_dist,-264+DNAloopOctavoDist-input_lane0_dist,gp.flip_x)
         ).t(2*DNA_outershell_dist+6,46,gp.flip) -- NW ori construction .. length critical
    +(snarkNES.state(output_layer_state)
      +(gpo.block.t(26,21)+gpo.block.t(4,46)+gpo.loaf.t(1,40,gp.flip)).state(SoD_state)
         +gpo.glider[3].t(2,4,gp.flip).state(comment_glider_state)
         +gpo.glider[3].t(-37,61,gp.rccw).state(comment_glider_state)
     ).t(16+25+116+2*shell_lane0_dist+6*shell_lane_dist+shell_last_extra_dist,16+25+1-shell_last_extra_dist , gp.flip) -- dna fill
    +(scorbieSE_withSoD2p1+
         (gpo.loaf.t(22,-20,gp.flip)+gpo.beehive.t(19,-39)+gpo.boat.t(-42,9,gp.rcw)).state(SoD_state) -- destroyal path
         +gpo.eater.t(-32,-26,gp.swap_xy_flip).state(output_layer_state) -- to block the lane not going to shell construction
         ).t(-69+DNA_outershell_dist+constr_lane_dist,65+constr_lane_dist-DNA_outershell_dist) -- SW shell construction
    +(gpo.eater.t(0,0,gp.flip_y).state(output_layer_state) -- state reading stoper (construction continues in DNA_loop_snarks)
      +(gpo.boat.t(-40,-35,gp.flip)  -- state reading stopper destroy
         +gpo.tub.t(-35,-92)+gpo.blinker.t(-22,-91)  -- split to 2nd bondersnatch destroy
         +gpo.blinker.t(20,-45,gp.rcw)+gpo.blinker.t(24,-45,gp.rcw) -- turn to destroy 2nd bondersnatch
         ).state(SoD_state)
         +(gpo.boat.t(3,-19,gp.flip)+gpo.boat.t(21,-13,gp.rcw)+gpo.loaf.t(6,-27,gp.rccw)+(gpo.blinker.t(9,-41)+gpo.blinker.t(10,-42))[1]
         +gpo.boat.t(-55,-70)+gpo.long_boat.t(-62,-78,gp.rccw)
         ).state(seed_state) -- state reading stoper replacement
         ).t(89+DNA_outershell_dist+constr_lane_dist+DNAloopOctavoDist,1+constr_lane_dist-DNA_outershell_dist-DNAloopOctavoDist)
 W=W+((gpo.boat.t(-6,5)+gpo.block.t(-14,7)).state(SoD_state).t(-310-open_kernel_lane,310-open_kernel_lane)).t(0,0,gp.flip) -- SW ori construction start

 -- W=W+(snarkNES.t(0,0,gp.swap_xy).state(output_layer_state)
--  +scorbiesplitter_withSoD.t(-185,-144)
--  +gpo.eater.t(28,-4,gp.rccw).state(output_layer_state)
--  +gpo.glider[1].state(comment_glider_state).t(-142,-161,gp.flip_y)
--  +(gpo.block.t(21,26)+gpo.eater.t(27,25)+gpo.boat.t(37,16,gp.rccw)).state(SoD_state)).t(135,41).t(2*output_lane_dist,0,gp.flip)
end

local function S_output()
 S=S+(scorbiesplitter_withSoDp1
    +(gpo.boat.t(66, 50,gp.rccw) + gpo.boat.t(59, 45,gp.rccw) + gpo.eater.t(50,44,gp.swap_xy)).state(output_layer_state)
    +(gpo.ship.t(140,-139)+gpo.blinker.t(148,-126)).state(SoD_state)
    +(scorbiesplitter_withSoD
      +(gpo.beehive.t(116,-119,gp.rcw)+gpo.pond.t(107,-115)).state(SoD_state)
     ).t(90,47)
    +(snarkNES.state(output_layer_state)
      +(gpo.blinker.t(29,0,gp.rcw)+gpo.tub.t(125,-100)+gpo.blinker.t(112,-99,gp.rcw)).state(SoD_state)
     ).t(145, 94)
    +(snarkNES.state(output_layer_state)
      +(gpo.blinker.t(-2,18)).state(SoD_state)
     ).t(525-DNAloopOctavoDist+input_lane0_dist+input_lane1_dist,-264+DNAloopOctavoDist-1-input_lane0_dist-input_lane1_dist,gp.flip_x)
    +(gpo.eater.state(output_layer_state)+(gpo.pond.t(-16-97,14+97)+gpo.blinker.t(-10-97,20+97)).state(SoD_state)).t(137,89)).t(46-1,-2*DNA_outershell_dist-6,gp.rcw) --fill prevent and its SoD
    +(snarkNES.state(output_layer_state)
      +gpo.glider[1].t(0,2,gp.flip).state(comment_glider_state)
      +(gpo.block.t(26,21)+gpo.loaf.t(-48,85,gp.flip)+gpo.block.t(-42,88)).state(SoD_state)
     ).t(102-shell_last_extra_dist, -95-2*shell_lane0_dist-6*shell_lane_dist-shell_last_extra_dist, gp.rcw)
    +snarkNES.state(output_layer_state).t(80+constr_lane_dist-DNA_outershell_dist,56-DNA_outershell_dist-constr_lane_dist,gp.flip_x)
    +((gpo.block+gpo.boat.t(25,30)).state(SoD_state) -- destroyal path + SoD
         +gpo.eater.t(-15,24,gp.flip_x).state(output_layer_state)) -- to block the lane not going to shell construction
         .t(53+constr_lane_dist-DNA_outershell_dist,77-DNA_outershell_dist-constr_lane_dist)
 S=S+((gpo.boat.t(-6,5)+gpo.block.t(-14,7)).state(SoD_state).t(-310-open_kernel_lane,310-open_kernel_lane)).t(0,0,gp.rcw)
 --S=S+(snarkNES.t(0,0,gp.swap_xy).state(output_layer_state)
 -- +scorbiesplitter_withSoD.t(-185,-144)
 -- +gpo.eater.t(28,-4,gp.rccw).state(output_layer_state)
 -- +gpo.glider[1].state(comment_glider_state).t(-142,-161,gp.flip_y)
 -- +(gpo.block.t(21,26)+gpo.eater.t(27,25)+gpo.boat.t(37,16,gp.rccw)).state(SoD_state)).t(135,41).t(0,-2*output_lane_dist,gp.rcw)
end

local function DNA_loop_snarks()
 local shift = 82+4*(DNAtimelog%2)
 local speedupshift=4*19
 local L=(snarkNES.state(output_layer_state).t(-14,10,gp.rccw)
         +(gpo.blinker.t(-14,-19,gp.rcw)
           +gpo.blinker.t(0,-28)+gpo.blinker.t(-1,-27)+gpo.boat.t(-14,-12)+gpo.long_boat.t(-17,-14,gp.rcw)
           +gpo.boat.t(-18,0,gp.rcw)+gpo.tub.t(-178,-171)+gpo.blinker.t(-177,-158)+gpo.boat.t(-101,-245,gp.flip)
          )[1].state(SoD_state)).t(3*DNAloopOctavoDist,DNAloopOctavoDist,gp.flip)                                                                                                           -- 1 dna loop delay
         +gpo.boat.state(output_layer_state).t(-16+149,-16+178+4*DNAloopOctavoDist,gp.flip) -- destroy fill reflector
         +(snarkNES.state(output_layer_state).t(-14,10,gp.rccw)+(gpo.blinker.t(-14,-19,gp.rcw)+gpo.boat.t(-14,-12,gp.flip))[1].state(SoD_state)
         +(gpo.boat.t(16, -56, gp.flip) -- start NE construction
          +gpo.boat.t(21, -61, gp.flip) -- start SE construction
          +gpo.boat.t(26, -66, gp.flip) -- start SW construction
          +gpo.boat.t(31, -71, gp.flip) -- start NW construction
          +gpo.block.t(34, -77) -- delay to fill the DNA in NW as well
          +gpo.block.t(37, -80) -- delay to fill the DNA in NW as well
          +gpo.block.t(40, -83) -- delay to fill the DNA in NW as well
          +gpo.boat.t(45, -85, gp.flip) -- remove DNA
          +gpo.eater.t(76, -117, gp.flip_y) -- catching late "speedup" gliders
          +gpo.boat.t(73, -131, gp.flip) -- destroy the eater at the end of 0 speedup
          +gpo.block.t(56, -101)+gpo.loaf.t(50, -97, gp.rcw) -- send state + start SoD splitter
          ).state(output_layer_state)
         +(gpo.block.t(85, -130)+gpo.block.t(89, -124)).state(SoD_state)
         ).t(2+2*DNAloopOctavoDist,2*DNAloopOctavoDist,gp.rcw)                                                                                                                           -- 6 dna loop delay
         +gpo.boat.state(output_layer_state).t(-16+2+2*DNAloopOctavoDist,-16+32+2*DNAloopOctavoDist,gp.flip) -- first glider redirect to switch fill to clocks construction
         +gpo.tub.state(output_layer_state).t(-16+31+2*DNAloopOctavoDist,-16+55+2*DNAloopOctavoDist)  -- part1 turn to start clocks construction
         +gpo.blinker.state(output_layer_state).t(-16+32+2*DNAloopOctavoDist,-16+42+2*DNAloopOctavoDist) -- part2 turn to start clocks construction
         +gpo.blinker.state(output_layer_state).t(-16+157+2*DNAloopOctavoDist,-16+179+2*DNAloopOctavoDist,gp.rcw) -- part1 turn to destroy fill reflector
         +gpo.blinker.state(output_layer_state).t(-16+157+2*DNAloopOctavoDist,-16+175+2*DNAloopOctavoDist,gp.rcw) -- part2 turn to destroy fill reflector
         +(snarkNES.state(output_layer_state).t(-14,10,gp.rccw)
          +(gpo.block.t(7,-17)
            +gpo.block.t(23,-4)+gpo.loaf.t(17,0,gp.rcw)
            ).state(SoD_state)
          +(boatsemisnarkwithSoD + semisnarkready).t(-129+1,-157-1) -- to make children and die
          +(gpo.tub.t(245,186)+gpo.tub.t(236,177)+gpo.tub.t(227,168)+gpo.tub.t(218,159)+gpo.tub.t(209,150)+gpo.tub.t(200,141)
          +gpo.boat.t(225,195,gp.flip)+gpo.boat.t(216,186,gp.flip)+gpo.boat.t(207,177,gp.flip)+gpo.boat.t(198,168,gp.flip)+gpo.boat.t(189,159,gp.flip)+gpo.boat.t(180,150,gp.flip)
          +gpo.blinker.t(232,187)+gpo.blinker.t(223,178,gp.rcw)+gpo.blinker.t(214,169)+gpo.blinker.t(205,160,gp.rcw)+gpo.blinker.t(196,151)+gpo.blinker.t(187,142,gp.rcw)
          +gpo.boat.t(183,135,gp.flip)  -- 0 speedup
         +(gpo.block.t(232,194)+gpo.block.t(223,185)+gpo.block.t(214,176)+gpo.block.t(205,167)+gpo.block.t(196,158)+gpo.block.t(187,149)
           +gpo.boat.t(242,186,gp.rccw)+gpo.tub.t(236,177)+gpo.tub.t(227,168)+gpo.tub.t(218,159)+gpo.tub.t(209,150)+gpo.tub.t(200,141)
           +gpo.boat.t(225,195,gp.flip)+gpo.boat.t(216,186,gp.flip)+gpo.boat.t(207,177,gp.flip)+gpo.boat.t(198,168,gp.flip)+gpo.boat.t(189,159,gp.flip)+gpo.boat.t(180,150,gp.flip)
           +gpo.blinker.t(223,178)+gpo.blinker.t(214,169,gp.rcw)+gpo.blinker.t(205,160)+gpo.blinker.t(196,151,gp.rcw)+gpo.blinker.t(187,142)
           +gpo.boat.t(183,135,gp.flip)).t(-speedupshift,-speedupshift)
         -- <7 speedup
          ).state(output_layer_state)
          ).t(4+DNAloopOctavoDist,DNAloopOctavoDist,gp.identity)                                                                                                                           -- 5 dna loop delay
         +(snarkNES.state(output_layer_state).t(-14,10,gp.rccw)
          +(gpo.blinker.t(-14,-19,gp.rcw)
            +gpo.blinker.t(0,-28)+gpo.blinker.t(-1,-27)+gpo.boat.t(-14,-12)+gpo.long_boat.t(-17,-14,gp.rcw)
           )[1].state(SoD_state)).t(3,2*DNAloopOctavoDist,gp.flip_y)                                                                                                                        -- 4 dna loop delay
         +(snarkNES.state(output_layer_state).t(-14,10,gp.rccw)
          +(gpo.blinker.t(-14,-19,gp.rcw)
            +gpo.blinker.t(0,-28)+gpo.blinker.t(-1,-27)+gpo.boat.t(-14,-12)+gpo.long_boat.t(-17,-14,gp.rcw)
           ).state(SoD_state)).t(shift+1-2*DNAloopOctavoDist,shift,gp.swap_xy)                                                                                                             -- 3 dna loop delay
         +(snarkNES.state(output_layer_state).t(-14,10,gp.rccw)
          +(gpo.block.t(7,-17)
            +gpo.block.t(23,-4)+gpo.loaf.t(17,0,gp.rcw)
           ).state(SoD_state)).t(shift-1,shift-2*DNAloopOctavoDist,gp.flip_x)                                                                                                               -- 2 dna loop delay
         +(scorbiesplitter_withSoD
                 +(gpo.boat.t(60,24) -- turn to open state fill
                 +gpo.pond.t(21,2)+gpo.beehive.t(25,-4) -- fill/clock build scorbiesplitter destroy
                 +gpo.pond.t(37,53)+gpo.beehive.t(33,47)).state(SoD_state) -- fill bondersnatch destroy
                 +gpo.boat.t(130,45).state(seed_state) -- turn to close state fill
                 +snarkNES.state(output_layer_state).t(123,169) -- state fill
                 +gpo.block.t(149,190).state(SoD_state) -- snarkSoD
                 +(gpo.loaf.t(69,266)+gpo.eater.t(64,268,gp.swap_xy)).state(output_layer_state) -- send state snark SoD spitter
         ).t(4+3*DNAloopOctavoDist,346+DNAloopOctavoDist,gp.rcw) --dna fill/clocks construction
         +gpo.eater.t(-16-160+3*DNAloopOctavoDist,-16+236+DNAloopOctavoDist,gp.swap_xy_flip) -- clocks construction blocker
         --debug stuff
    --     +gpo.eater.t(-16-225+3*DNAloopOctavoDist,-16+170+DNAloopOctavoDist,gp.flip) -- debug stop clock recipe
    --     +gpo.block.t(-16-220+3*DNAloopOctavoDist,-16+183+DNAloopOctavoDist) -- debug stop clock recipe
    --     +gpo.block.t(-16-189+3*DNAloopOctavoDist,-16+203+DNAloopOctavoDist) -- debug stop clock recipe
 return L.t(0,0,gp.flip)
end

local function ReadClock()
 local readclock=pattern()
 readclock.array=g.parse([[
332bo$332b3o$335bo$334bobo$334bobo$335bo5$350b2o$350b2o4$330b2o$329bob
o$329bo$328b2o7b2o$337b2o2$345b2obo$345b2ob3o$351bo$238bo106b2ob3o$
238b3o105bobo$241bo104bobo$240b2o6b2o97bo$247bobo$248bo99bo$346b3o$
345bo$235b2o108b2o$235b2o6b2o92b2o$243b2o92b2o2$252b2o$252b2o2$237b2o$
236bobo87b2o$236bo90bo$235b2o90bobo$328b2o3$323b2o$324bo$324bobo$325b
2o2$265bo8b2o$265b3o6b2o$268bo$220b2o45b2o13b2o62b2o$220b2o60bo63bo$
280bobo64b3o$280b2o67bo$211b2o$211bobo59b2o$212bo60b2o3$217b2o60bo$
217b2o59bobo$279b2o$210b2o$85b2o11bo110bobo$85b2o10bobo109bo60b2o$97bo
bo31b2o75b2o13b2o45b2o$96b2ob3o2b2o25bo91bo$102bo2bo23bobo84b2o6b3o$
96b2ob3o3bobo21b2o85b2o8bo$96b2obo6b2o4$191bo$191b3o$194bo$93b2o13b2o
83bobo$93b2o13b2o83bobo$78b2o114bo$77bo2bo$76bob2o$76bo$75b2o$90b2o
117b2o$90bo118b2o$91b3o23b2o$93bo24bo$115b3o4b2o$115bo6b2o65b2o$188bob
o$188bo86b2o6bo$187b2o7b2o77b2o4b3o$196b2o82bo24bo$280b2o23b3o$204b2ob
o100bo$204b2ob3o97b2o$210bo17b2o92b2o$204b2ob3o18b2o92bo$205bobo111b2o
bo$205bobo17b2o91bo2bo$206bo6b2o10b2o92b2o$213b2o74b2o13b2o$207bo14b2o
65b2o13b2o$205b3o14b2o$204bo$204b2o13b2o$196b2o21b2o$196b2o$216b2o$
216b2o73b2o6bob2o$268b2o21bobo3b3ob2o$147bo119bobo23bo2bo$147b3o62b2o
53bo25b2o2b3ob2o$150bo34b2o25b2o52b2o31bobo$149b2o6b2o27bo93b2o17bobo
10b2o$156bobo27bobo20b2o69b2o18bo11b2o$157bo29b2o20b2o$283b2o$283b2o
10b2o$144b2o149b2o$144b2o6b2o31b2o99b2o$152b2o31b2o99b2o2$161b2o126b2o
$161b2o126b2o2$146b2o144b2o$145bobo57b2o85b2o$145bo59bo$144b2o60b3o86b
2o$208bo52b2o32b2o$261bo$240b2o17bobo36b2o$233b2o5b2o17b2o37b2o$233b2o
$326b2o$326bobo$235b2o27b2o61bo$235b2o27b2o$229b2o$229b2o$270b2o$222bo
47b2o$222b3o41b2o$225bo40b2o$224b2o3$271b2o$271b2o$3b2o363bo$4bo363b3o
$2bo368bo$2b5o14b2o347b2o6b2o$7bo13bo355bobo$4b3o12bobo356bo$3bo15b2o$
3b4o106b2o145b2o$b2o3bo3b2o101b2o145b2o103b2o$o2b3o4b2o353b2o6b2o$2obo
369b2o$3bo100b2o149b2o$3b2o99bobo148b2o125b2o$105bo118b2o156b2o$224b2o
$11b2o180b2o172b2o$12bo97b2o81b2o171bobo$9b3o98b2o134b2o4b3o111bo$9bo
186b2o31b2o14bobo117b2o$103b2o91b2o31b2o15bo$102bobo120b2o$102bo96b2o
24b2o$101b2o13b2o81b2o65b2o$116bo149b2o$109b2o6b3o82b2o27b2o27b2o$109b
2o8bo82b2o27b2o27b2o$475bo$395bo8b2o67b3o$206b2o54b2o131b3o6b2o66bo$
206b2o47b2o5b2o134bo73b2o$255b2o38b2o100b2o13b2o$209b2o62b2o20b2o115bo
$209b2o62bobo134bobo67b2o$274bo135b2o69bo$148b2o62b2o90b2o175bob2o$
148bo63b2o89bobo97b2o68b2o4b3o2bo$146bobo155bo5b2o91b2o68b2o3bo3b2o$
146b2o35b2o11bo113b2o166b4o$183b2o10bobo266b2o15bo$131b2o62bobo31b2o
178bo53bobo12b3o$131b2o61b2ob3o2b2o25bo70b2o106bobo52bo13bo$200bo2bo
23bobo70b2o107b2o51b2o14b5o$140b2o52b2ob3o3bobo21b2o76b2o175bo$140b2o
6b2o44b2obo6b2o99bobo172bo$148b2o157bo92b2o78b2o$292b2o13b2o91b2o$293b
o$136bo153b3o6b2o$135bobo152bo8b2o$135b2o6b2o$143bo47b2o13b2o$144b3o
44b2o13b2o$146bo29b2o$175bo2bo$174bob2o$174bo$173b2o$188b2o195b2o$188b
o196bo$189b3o23b2o166bobo$191bo24bo166b2o$213b3o4b2o109b2o$213bo6b2o
109b2o35b2o$368b2o$328b2o$328b2o47b2o$377b2o6b2o$325b2o58b2o$325b2o2$
322b2o49bo$322b2o48bobo$372b2o6b2o$319b2o59bo$243b2o74b2o60b3o$244bo
138bo$244bobo69b2o$245b2o69b2o2$260b2o51b2o$260b2o51b2o3$243b2o$243b2o
5b2o$250b2o2$256bo$255bobo$248b2o6b2o$249bo$246b3o42b2o$246bo45bo81bo$
290bo81b3o$254b2o34b5o14b2o60bo$254b2o39bo13bo61b2o7bo$292b3o12bobo68b
3o$291bo15b2o68bo24bo$291b4o82b2o23b3o$289b2o3bo3b2o105bo$288bo2b3o4b
2o104b2o$288b2obo127b2o$291bo127bo$291b2o123b2obo$415bo2bo$416b2o$299b
2o85b2o13b2o$300bo85b2o13b2o$297b3o$297bo5$388b2o6bob2o$365b2o21bobo3b
3ob2o$364bobo23bo2bo$364bo25b2o2b3ob2o$363b2o31bobo$396bobo10b2o$397bo
11b2o6$120bo$120b3o$123bo$122b2o5$143b2o$143bobo$145bo$145b2o3$140b2o$
140bobo$142bo$142b2o6$131b2o$131b2o$123b2o$124bo$121b3o$121bo2$122bo$
121bobo$121bobo$119b3ob2o$118bo$119b3ob2o$121bob2o2$131b2o$131b2o7b2o$
140bo$138bobo$138b2o4$118b2o$118b2o5$134bo$133bobo$133bobo$134bo$135b
3o$137bo59$214bo$214b3o$217bo$216b2o7$226b2o$219b2o5bobo$219b2o7bo$
228b2o2$215bo$214bobob2o$214bobobobo$211b2obobobobo2bo$211bo2bo2b2ob4o
$213b2o4bo$219bobo$220b2o!
]])
 local readclockSoD=pattern()
 readclockSoD.array=g.parse([[
72b2o$72b2o2$315b3o3$68b2o$68b2o4$347bo$346bobo$346bobo$347bo3$241b2o$
90b2o149b2o$83b3o4bobo$91bobo$92bo7$84b2o$84bobo$86bo$86b2o2$227bo$
226bobo86b3o$226bobo51b2o$227bo52b2o2$97b3o3$254b2o28b2o$254b2o28b2o$
103b3o118b2o37b2o$224b2o36bo2bo$263b2o9$92bo$92bo17b3o$92bo107b2o$200b
2o$280b2o$280b2o11$217b2o$216bo2bo$217b2o$226b2o$226b2o$202bo$201bobo$
201b2o7$273b2o5b3o$273b2o7$233bo6b2o$232bobo4bobo$233b2o5bo4$124b2o$
124b2o5$120b2o$120b2o8bo$129bobo$129b2o$150b2o$150b2o$173b3o$314b2o$
314bobo$315bo4$174b2o$174b2o4$216bo$215bobo$136bo79b2o$135bobo$135bobo
$136bo7$133b2o$133b2o$126bo$125bobo$125bobo$126bo4$125bo$124bobo$124bo
bo$125bo$201b2o168b2o$200bobo168b2o$201bo68b2o$270b2o3$285b3o$274bo$
274bo$274bo$193b2o$193bobo$194bo4$93b2o262bo$93b2o99b2o160bobo$193bobo
160bobo$194bo162bo4$b2o$o2bo380b2o$o2bo380b2o$b2o351b2o37b2o$354b2o36b
o2bo$155b2o52bo72b2o109b2o$66bo87bobo52bo71bo2bo$65bobo42b2o43bo53bo
72b2o$66b2o41bo2bo36b2o$110b2o37b2o$89b2o28b2o$7b2o80b2o28b2o98b2o$7bo
bo209b2o26b2o$8bo176b2o59bo2bo$184bo2bo58bo2bo$185b2o60b2o$93b2o52bo$
93b2o51bobo102b2o$146bobo101bo2bo156b2o$147bo103b2o5b3o149b2o4$455bo$
455bo$455bo5$288b2o$287bo2bo95b2o$288b2o96b2o$279b2o$132b2o29bo115b2o$
132b2o29bo$163bo3$384bo$383bobo$221b2o160bobo$220bobo161bo$221bo5$232b
2o$232b2o4$225b2o$224bo$227bo72bo$225b2o8bo63bobo$234bobo62bo2bo66b2o$
234bobo63bobo66b2o$235bo65bo3$299b2o$299bobo$300b2o3$278b2o$278b2o2$
376b3o28b3o13$276b2o$276b2o5$280b2o$157b2o121b2o$156bobo$157bo8$398b2o
$397bo2bo$398b2o13$356bo$355bobo$342b3o11bo8$142b3o20$112bo$111bobo$
111bobo$112bo8$142b3o80$227b2o$226bo2bo$226bo2bo$227b2o!
]])
 readclockSoD=readclockSoD.t(0,-3)
 local send_state_salvo_seed=pattern()
 send_state_salvo_seed.array=g.parse([[
2o$2o6$2b3o72$92b2o$91bo2bo$91bo2bo$92b2o3$87b3o8$93b2o$93b2o5$96bo$
96bo$96bo57$171b2o$170bo2bo$170bo2bo$171b2o2$167bo$167bo$167bo7$172b2o
$172b2o6$174b3o44$236b2o$235bo2bo$235bo2bo$236b2o3$231b3o8$237b2o$237b
2o5$240bo$240bo$240bo29$287b2o$286bo2bo$286bo2bo$287b2o2$283bo$283bo$
283bo7$288b2o$288b2o6$290b3o16$324b2o$323bo2bo$323bo2bo$324b2o3$319b3o
8$325b2o$325b2o5$328bo$328bo$328bo$347b2o$346bo2bo$346bo2bo$347b2o2$
343bo$343bo$343bo6$359bo$358bobo$357bobo$357b2o3$352b2o$351bo2bo$352b
2o!
]])
 local S=2 -- SW shift of SoD incomming glider
 local C=3 -- SW shift for clock semi lane
 local D=1 -- SW shift of after a while destroyal
 local X=23
 return (readclock.state(output_layer_state)+readclockSoD.t(5,7).state(SoD_state) --+gpo.boat.t(225,115).state(seed_state)
         +gpo.glider[1].t(324,134,gp.flip_y).state(comment_glider_state) -- clock starting glider
         +gpo.glider[1].t(55,116,gp.rcw).state(comment_glider_state) -- state sending circuit destroying glider
         +((gpo.block.t(30,30)+gpo.block.t(-12,-12)+gpo.block.t(-16,-16)+gpo.block.t(-20,-20)+gpo.block.t(-24,-24)+gpo.block.t(-28,-28)+gpo.block.t(-34,-34) -- state blocks
           +gpo.block.t(-44,-27)+gpo.blinker.t(-37,-29, gp.rcw) -- nonzero antispeedup
           +gpo.blinker.t(20,35)+gpo.tub.t(28,37)+gpo.eater.t(50,32,gp.swap_xy)+gpo.boat.t(55,46,gp.flip) -- state 7 antispeedup
           ).state(output_layer_state)
         +(gpo.long_boat.t(-272-S,-555+S, gp.rcw) -- SoD source
          +gpo.pond.t(88-S,-179+S)+gpo.beehive.t(97-S,-183+S,gp.rcw) -- repeat test zero and <7 split after state zeroed
          +gpo.block.t(-60,-19) -- catch zero destroyal for nonzero case
          +gpo.boat.t(179-S,-98+S,gp.flip)+gpo.loaf.t(171-S,-95+S,gp.rcw) -- repeat test 7 and continue to reflectors after a while split
          +gpo.block.t(13,58) -- catch 7 destroyal for <7 case
          +gpo.boat.t(338-S,72+S,gp.rcw)+gpo.boat.t(358-2-D,43+2+D) -- turnback after a while
          +gpo.block.t(202-D,-110+D)+gpo.block.t(207-D,-107+D)+gpo.boat.t(205-D,-115+D,gp.rcw) -- reflector for 7 case with catcher (<7 destroys the boat) but we need a pseudocatalyst and destroy it
          +gpo.pond.t(178+1-D,-123+1+D)+gpo.blinker.t(184+1-D,-126+1+D) -- split back to destroy the pseudocatalyst
          +gpo.loaf.t(165+3-D,-131+3+D)+gpo.block.t(161+3-D,-138+3+D) -- split to destroy 0,<7 catchers and half turn to conditional reflector for 7
          +gpo.loaf.t(-29+X+3,7+X+3,gp.rccw)+gpo.block.t(-33+X+3,13+X+3) -- targeting the catchers
          +gpo.loaf.t(166+3-D,-146+3+D,gp.rcw)+gpo.block.t(172+3-D,-150+3+D) -- split to 0 and second half turn to conditional reflector for 7
          +gpo.pond.t(155-D,-167+D)+gpo.block.t(148-D,-164+D) -- turn back to destroy catcher
          +gpo.blinker.t(47-D,-264+D)+gpo.tub.t(56-D,-265+D) -- turn back to hit the nonzero reflector
          +gpo.block.t(142-D,-197+D)+gpo.boat.t(139-D,-201+D,gp.rcw) -- reflector for nonzero case ... vanishing in both cases (zero destroys the boat)
         -- 7 antispeedup SoD stop
          ).state(SoD_state)
           ).t(220,-100)
         +(gpo.tub+gpo.blinker.t(1,-13,gp.rcw)).state(SoD_state).t(-176,-515)
         +send_state_salvo_seed.state(output_layer_state).t(-173,-504)+gpo.glider.t(-86,-428,gp.flip).state(comment_glider_state)
         +(gpo.boat.t(541,-128,gp.flip)+gpo.long_boat.t(544,-126,gp.rccw)                                                     -- allow readclock start from NE
         +gpo.boat.t(372,322,gp.rccw)+gpo.long_boat.t(370,325)+gpo.boat.t(683,19)+gpo.loaf.t(516,-142)+gpo.boat.t(515,-150)   -- allow readclock start from SE
         +gpo.boat.t(151,241,gp.flip)+gpo.long_boat.t(153,244,gp.rcw)+gpo.boat.t(16,114,gp.rcw)+gpo.boat.t(412,-274)          -- allow readclock start from SW
         +gpo.boat.t(177,72,gp.rccw)+gpo.long_boat.t(174,74,gp.flip)+gpo.boat.t(463,-223)                                     -- allow readclock start from NW
         +gpo.boat.t(335-C,-277+C,gp.rcw)+gpo.blinker.t(331-C,-282+C,gp.rcw)+gpo.blinker.t(332-C,-281+C,gp.rcw)               -- conditional state 0 turn (0 speedup)
         +gpo.long_boat.t(405-C,-211+C,gp.flip)+gpo.boat.t(411-C,-201+C,gp.rccw)+gpo.long_boat.t(408-C,-199+C,gp.flip)        -- conditional state <7 split (<7 speedup)
         ).state(output_layer_state)
         + (gpo.block.t(276,136)+gpo.block.t(279,229)+gpo.block.t(217,175)+gpo.block.t(231,127)                               -- to allow optional 0 neighbour
         + gpo.boat.t(581,-176,gp.rccw) + gpo.blinker.t(743,-24) + gpo.blinker.t(743,-20) -- to replace 0 from NE
         + gpo.pond.t(486,222)+gpo.beehive.t(495,226,gp.rcw) -- to destroy snark
         + gpo.loaf.t(387,325,gp.flip)+gpo.block.t(393,328) -- split to replace 0 from SE and NE
         + gpo.boat.t(378,337) -- to replace 0 from SE
         + gpo.pond.t(170,275)+gpo.beehive.t(174,284)+ gpo.boat.t(132,252,gp.rcw)  -- to replace 0 from SW
         + gpo.ship.t(128,33,gp.rcw)+gpo.blinker.t(141,25,gp.rcw)+gpo.blinker.t(158,5,gp.rcw)+gpo.blinker.t(162,5,gp.rcw) -- to replace 0 from NW
         + gpo.boat.t(17,146,gp.rcw) + gpo.boat.t(296,434) -- SoD starting path
         ).state(SoD_state)
       ).t(384-innerquadsize,-355)
end

local function mainClock()
 local SE_part=pattern()
 SE_part.array=g.parse("20bo$19bobo$19bobo$2b2ob2o13bo$o2bob2o$2obo$3bo$3b2o$b2o2bobo7bo$o2bo2b2o6bobo$b2o12bo4$12b2o3b2o$13bo3bo$10b3o5b3o$10bo9bo!")
 local SE_partSoD=pattern()
 SE_partSoD.array=g.parse([[
6bo$6bo$6bo2$b2o$o2bo$o2bo$b2o25$44b2o$43bobo$42bobo$43bo9$56b2o$55bob
o$54bobo$55bo8$67b2o$66bobo$65bobo$66bo8$78b2o$77bobo$76bobo$77bo8$89b
2o$88bobo$87bobo$88bo7$99b2o$98bobo$97bobo$98bo159$415b2o$415b2o30$
414b2o$414b2o4$418b2o$418b2o70$353b2o$352bobo$353bo!
]])
 local NW_part=pattern()
 NW_part.array=g.parse([[
39b2o$39bo$18b2o17bobo$11b2o5b2o17b2o$11b2o3$13b2o27b2o$13b2o27b2o$7b
2o$7b2o$48b2o$o47b2o$3o25bo15b2o$3bo23bobo14b2o$2b2o16b3o4b2o3$49b2o$
49b2o6$13b2o$13b2o3$8b2o$8b2o3$2b2o$2b2o4$7b2o$7b2o$3b2o$3b2o$44b2o$
44b2o$9b2o27b2o$9b2o27b2o3$40b2o$15b2o16b2o5b2o$16bo16b2o$13b3o$13bo
40b2o$54bobo$56bo$56b2o$58bo$56b3o$55bo$43b2o10b2o$43b2o2$46b2o$46b2o
2$49b2o$49b2o$54b2o$55bo$52b3o$52bo!
]])
 local NW_partSoD=pattern()
 NW_partSoD.array=g.parse([[
75bo$75bo$75bo$92b3o27$107b2o$107b2o6$106bo$106bo$34b2o70bo$33bobo$34b
o60bo$94bobo$94bo2bo$95b2o$99bo$99bo$99bo6$97bo$97bo$97bo6$48b2o$48bob
o$49bo26$6b3o4$b2o$o2bo$b2o$9bo$8bobo$7bobo$7b2o4$25b2o$24bobo$23bobo$
24bo4$32b2o$24bo6bobo$23bobo4bobo$22bobo6bo$22b2o4$31bo$30bobo$29bobo$
29b2o4$47b2o$46bobo$45bobo$46bo4$32bo$31bobo$32b2o!
]])

 return
 (SE_part.state(output_layer_state)+SE_partSoD.t(-396,-260).state(SoD_state)
  + (boatsemisnarkwithSoD+semisnarkready).t(24-1,130+1,gp.rccw)
  + (gpo.boat.t(18-1,109+1,gp.flip)+gpo.block.t(86-1,177+1)+gpo.block.t(92-1,173+1)+gpo.boat.t(84-1,169+1,gp.rccw)).state(SoD_state) --stop and start semisnark SoD (to wait for correct first semisnark state)
  + (gpo.boat.t(-31-1,12+1,gp.rccw)).state(output_layer_state) -- starting read clock
         --  + (gpo.loaf.t(-29,16,gp.rcw)+gpo.blinker.t(-32,27,gp.rcw)).state(output_layer_state) -- starting read clock
 ).t(973-innerquadsize,-458)
 +
 (NW_part.state(output_layer_state)+NW_partSoD.t(-46,1).state(SoD_state)+gpo.glider[1+2].t(-6-75115,13-75115,gp.swap_xy_flip).state(active_state)
  +(boatsemisnarkwithSoD+semisnarksemi).t(3-1,97+1)
  +(gpo.boat.t(35-1, 87+1, gp.flip) -- read state alarm clock gun start (we can use other barel of this gun instead)
   +gpo.block.t(25, 96) --
   ).state(output_layer_state)
  +gpo.boat.t(24, 91, gp.rccw).state(SoD_state) -- stops semisnark series destroyal
 ).t(-5069-innerquadsize,-6501)
end

local function cell(mark)
    local ret
    ret = E.t(2*innerquadsize,0)+N.t(0,-2*innerquadsize)+W.t(-2*innerquadsize,0)+S.t(0,2*innerquadsize)
            +SE.t(innerquadsize,innerquadsize)+NE.t(innerquadsize,-innerquadsize)+NW.t(-innerquadsize,-innerquadsize)+SW.t(-innerquadsize,innerquadsize)
    if mark then
        return ret + positionmark
    end
    return ret
end

local function long_blockF(x,y,d1,d2)
    return gpo.glider[1].state(5).t(x+d1+d2+9,y+d1-d2+8,gp.identity)+
        gpo.loaf.t(x+d1+d2,y+d1-d2+1,gp.flip_x)+gpo.beehive.t(x+d1+d2,y+d1-d2-8,gp.rcw)+gpo.boat.t(x+d1-2,y+d1+6,gp.identity)+gpo.boat.t(x+d2+3,y-d2-8,gp.flip_y)
     +gpo.block.state(4).t(x,y)
end

local function long_blockB(x,y,d1,d2)
    return gpo.glider[1].state(5).t(x+d2-1,y-d2-12,gp.flip)+
            gpo.ship.t(x+d1+d2+13,y+d1-d2-4)+gpo.blinker.t(x+d1+d2+9,y+d1-d2-1)+gpo.boat.t(x+d1-4,y+d1+4,gp.identity)+gpo.boat.t(x+d2+15,y-d2-9,gp.flip)+gpo.blinker.t(x+d2+9,y-d2-10,gp.rcw)
            +gpo.block.state(4).t(x,y)
end

local block_build_dist = 86+innerquadsize//2
local _0e0p_cellS = cell(true)
        + long_blockB((innerquadsize-475),0,block_build_dist-86,block_build_dist).t(0,0,gp.identity)
        + long_blockB((innerquadsize-475),0,block_build_dist-86,block_build_dist).t(0,0,gp.rcw)
        + long_blockF((innerquadsize-475),0,block_build_dist,block_build_dist-44).t(0,0,gp.flip)
        + long_blockB((innerquadsize-475),0,block_build_dist,block_build_dist).t(0,0,gp.rccw)
        --+ gpo.block.t() --AGJF Ori targets
        --+ gpo.block.t((innerquadsize-475),0,gp.identity) --+ gpo.block.t(0, (innerquadsize-475),gp.rcw)
        --+ gpo.block.t(-(innerquadsize-475),0,gp.flip) + gpo.block.t(0, -(innerquadsize-475),gp.rccw)
E_output()
N_output()
W_output()
S_output()
local _0e0p_cellF = cell(true)+DNA_loop_snarks()+ReadClock()+mainClock()
g.setrule("LifeHistory14")
local _0e0p_cells = _0e0p_cellF+_0e0p_cellF.t(-halfsize,-halfsize)+_0e0p_cellF.t(halfsize,-halfsize)+_0e0p_cellS.t(halfsize,halfsize)+_0e0p_cellF.t(-halfsize,halfsize)
_0e0p_cells.display("0e0pcells")
g.setbase(2)
g.setstep(16)
g.setpos(startX,startY)
g.setmag(startMag)

Commenting out the inner components we would get what the shell building should accomplish. Of course target allocation for the inner build should be prepared as well, (on rotation symmetric positions as we do not know from which direction the shell is constructed).

I could be easier to thing without the waste distances between the components, what the script would be helpfull with as well ...

Hmm, modification

Code: Select all

innerquadsize = innerquadsize // 256
cell(true).display("0e0pshellOver256")

shows the code does not work well for different innerquadsize ... the scorbie insertors are at wrong positions...
... Changing DNAtimelog = 17 gives a reasonably small shell model ...

Here is "only shell" task ...

0e0pshellRotInputsMarked.mc

(90.06 KiB) Downloaded 73 times

it has rotational symmetry, only the parts with properly oriented labels will be actually used.
The shell is build by a single lane recipe comming near the corner ... through the eater slightly left from the marked output path.
(and we do not know through which corner it comes ... this is why rotational symetry of the shell)
The speboe block on te output path is missing in the example, but it should be active at the end of the construction.
Oriented cell inside would be build using single lane recipe starting with this speboe on the south corner.

We should (probably) also prepare rotation symmetric targets for the directed shell construction.

Looking at scorbie insertors we can see the seed of destruction in their proximity is the same (except the leftmost one where loaf (block and boat) are close as well. The "SoD input" reflectors would be build before the "specialised program for the insertor".

Similarly all snarks have the same block as SoD, but innermost one have barge, longboat, blinker, and pond in its proximity. ... is there a chance to modify snarkmaker to deal with it? The barge longboat blinker and pond could probably be rather easily put elsewhere, but the block is mandatory.

Looking on the oriented cell snarks (the DNA loop) ... there are other SoD additions then the block as well, but unifying them to the block SoD could be worth doing.

Oops, the slmarker envelope overlaps neighbouring snark:

Code: Select all

x = 218, y = 249, rule = LifeHistory14
32$93.yN49.4yN$92.3yN47.4yN$88.yN3.3yN6.2yN38.4yN$87.3yN.13yN36.4yN$
84.21yN9.yN24.4yN2A$84.21yN7.4yN22.5yN2A$83.23yN5.8yN7.yN.3yN6.9yN$
84.21yN6.9yN.12yN3.10yN$85.19yN7.23yN.12yN$87.18yN4.29yN2.7yN$86.51yN
.8yN$81.yN5.50yN.8yN$79.67yN$70.2yN6.71yN$68.5yN5.72yN$66.yN.5yN4.73yN
$64.10yN2.75yN$63.11yN2.74yN24.D$59.3yN.12yN.75yN17.7D$58.95yN15.D$
59.94yN42.yN$59.95yN40.2yN$61.94yN38.3yN$62.93yN19.D17.4yN$64.90yN14.
7D16.4yN$65.86yN7.yN9.D21.4yN$66.85yN6.3yN29.4yN$65.86yN6.3yN28.4yN$
66.84yN6.5yN26.4yN$67.13yN.69yN6.5yN13.D11.4yN$67.83yN6.5yN8.D.4D10.
4yN$68.83yN6.5yN22.4yN$69.82yN5.6yN21.4yN$68.10yN2D9yN2D4yN2D55yN3.7yN
20.4yN$67.5yN.4yND2yND3yND5yND5yND57yN.7yN2.3yN2.D11.4yN$62.2yN2.4yN
4.3yND12yND5yND57yN.7yN.4yN.D11.4yN$61.9yN4.2yN3D5yND5yND5yND58yN.12yN
DyN.D7.4yN$61.11yN2.3yND6yND5yND5yND58yN.13yN6D3.4yN$59.18yND6yND5yND
5yND74yND4yN.4yN$58.19yND6yN2D4yN2D4yN2D82yN$57.122yN$58.120yN$57.
120yN$57.119yN$59.16yN2K70yN2K26yN$61.14yN2K70yN2K25yN$60.113yN$59.5yN
.107yN$58.6yN.18yN2I70yN2I14yN$57.27yNI71yNI8yN.4yN$56.26yNI71yNI8yN
2.4yN$57.25yN5I14yN2I51yN5I4yN.4yN5.2I$57.30yNI13yNI57yNI3yN.4yN5.I$
58.26yN3I12yNIyNI54yN3I10yN.yNI.I$57.26yNI15yN2I54yNI3yN3.7yN.yN2I$
57.26yN4I68yN4I12yN$58.23yN2I3yNI3yN2I61yN2I3yNI3yN2I7yN$59.21yNI2yN
3I4yN2I60yNI2yN3IyN.2yN2I7yN$59.21yN2IyNI68yN2IyNI.yN3.10yN$61.22yNI
71yNI8.8yN$62.21yN2I70yN2I7.9yN$65.92yN8.3yN2.4yN$65.91yN7.5yN3.4yN$
63.28yN2I64yN6.2I7.4yN$62.30yNI65yN6.I8.4yN$62.27yN3I67yN2.3I10.4yN$
64.25yNI69yN2.I13.4yN$65.95yN16.4yN$65.96yN16.4yN$65.96yN17.4yN$65.
96yN18.4yN$65.97yN18.4yN$66.96yN19.4yN$67.97yN18.4yN$68.98yN17.4yN$
69.97yN18.4yN$70.96yN19.4yN$71.95yN20.4yN$71.94yN22.4yN$70.96yN22.4yN
$60.3yN8.96yN22.4yN$60.5yN5.96yN24.4yN$58.8yN5.95yN25.4yN$57.10yN4.
94yN27.4yN$55.105yN2.3yN28.3yN$54.105yN4.yN30.2yN$55.105yN35.yN$57.
104yN$59.102yN$60.4yN.96yN$61.100yN$62.4yN.93yN$63.98yN$64.100yN$65.
99yN$66.99yN$67.99yN$68.97yN$69.96yN$70.94yN$70.94yN$70.93yN$70.10yN.
80yN$72.6yN4.78yN$72.7yN3.77yN$73.7yN2.76yN$73.8yN.75yN$74.yN3.4yN2.
73yN$79.4yN3.71yN$80.4yN.71yN$81.74yN$82.73yN$78.3yN.73yN$77.77yN$77.
78yN$75.75yN2.4yN$75.75yN3.4yN$75.74yN5.4yN$75.73yN7.4yN$76.63yN.7yN
9.4yN$77.63yN2.3yN12.4yN$77.64yN2.yN14.4yN$78.2yN.61yN17.4yN$84.46yN.
10yN19.4yN$85.29yN.16yN.8yN21.4yN$86.5yN.22yN2.14yN2.7yN23.4yN$88.2yN
2.22yN3.12yN5.5yN24.4yN$93.21yN3.12yN5.5yN25.4yN$94.3yN.16yN6.8yN6.6yN
25.4yN$94.3yN.16yN7.yN.3yN8.5yN27.4yN$95.yN3.13yN23.4yN28.4yN$100.13yN
22.3yN30.4yN$100.12yN24.2yN31.4yN$101.11yN58.4yN$101.3yN.6yN60.4yN$
102.yN3.6yN60.4yN$106.5yN62.4yN$106.5yN63.4yN$107.3yN65.4yN$108.yN67.
4yN$177.4yN$178.4yN$179.4yN$180.4yN$181.4yN$182.4yN$183.4yN$184.4yN$
185.4yN$186.4yN$187.4yN$188.4yN$189.4yN$190.4yN$191.4yN$192.4yN$193.
4yN$194.4yN$195.4yN$196.4yN$197.4yN$198.4yN$199.4yN$200.4yN$201.4yN$
202.4yN$203.4yN$204.4yN$205.4yN$206.4yN$207.4yN$208.4yN$209.4yN$210.
4yN$211.4yN$212.4yN$213.4yN$214.4yN$215.3yN$216.2yN$217.yN!

This is strong incentive to increase the distance between shell spirall lanes,
but it could be interesting to have a way to limit the envelope in the search program as well.

[dvgrn]

Oops, the slmarker envelope overlaps neighbouring snark...
This is strong incentive to increase the distance between shell spirall lanes,
but it could be interesting to have a way to limit the envelope in the search program as well.

It's definitely worthwhile for someone to independently get good at that new "grey goo" single-channel search technique. There are even shorter Snarkmakers still out there somewhere, with more compact envelopes... they're probably very hard to find, but it's hard to guess what the range of cost will be without trying several full builds from different starting points.

(Yes, each build probably needs something like a CPU-month of solid searching, with some inspired choices along the way, and constant heroic stepping away from almost-recipes that are just so close to working.)

My uneducated guess is that the current recipe probably starts using 0-degree recipes just a bit too early, and keeps using them even when non-glider shortcuts might be available. Supposing that russellsprouts kept on going after this current effort, and spent another month with equal amounts of patience and persistence building a new Snarkmaker from the ground up (or from step #13, maybe) ... I bet that it would come in another 10-25 gliders cheaper and with a somewhat smaller envelope.

I'm not suggesting that that should happen, of course -- russellsprouts definitely deserves a rest after this Herculean task! But this 266G recipe doesn't have to be the final word in Snarkmaker-making. I put a few wild ideas here, but please take this with a large pillar of salt because I haven't actually tried to run this kind of search myself yet.

[russellsprouts]

I've been thinking about how far you could reduce the fixed circuitry of a 0E0P cell. I'm probably missing a lot of details here, but I think you could build a metacell with very little fixed circuitry:

Symmetric components:

1. A splitter/reflector on each corner of the diamond to route the "DNA" around the perimeter of the cell. The reflector should have a transparent lane so that it can accept the DNA from the parent directly from its constructor arm output.
2. A constructor arm on the output of each splitter. The constructor arm is initially blocked with an eater. We also find a "stop codon" recipe which replaces that eater, so we can shut off a constructor arm at any time.
3. 4 programmable master clocks which unblock the constructor arms at specific times.

Non-symmetric components:

1. The programs for the master clocks.

Why I *think* this would work:

1. We can construct daughter cells one at a time by unblocking the construction arms in sequence.
2. We can divide construction into multiple steps with a stop codon, e.g., start crabstretcher, *stop*, unblock again, burn the fuse, build the rest.
3. We can ensure the DNA is the same phase in all daughter cells by choosing where to start the copy. We start copying with a delete elbow recipe, and we end copying by intercepting the stream with a master clock glider and recovering the elbow. We would have four copies of the sequence "delete elbow, recover elbow from crossing glider" in the stream, equally spaced.
4. To achieve asymmetry, we have 4 different recipes to build temporary snarks to move the construction arm to different orientations before sending the recipe for the master clock programs.
5. (Big handwaving) the construction arm can do the state calculations. E.g., we find recipes that detect gliders from the neighbor cells, store data in offset blocks, and send signals to the other cells. The lookup table may become 4096 recipes instead of 4096 gliders, but maybe it works out to be similarly efficient since one-time circuitry is much simpler.

Problems:

1. Would this be hashlife efficient?
2. The clock needs a large dynamic range -- it needs to send gliders exactly timed in times smaller than the period of the glider loop, including a repeat time smaller than the period of the loop, but also be able to wait for multiple loops, especially if there's a long "look like a cell" phase.
3. Efficiently packing the recipes into the DNA so that we can trigger them when needed and don't have to leave wide gaps or wait full cycles for things to come around again.
4. All the other things I haven't considered that would be blockers.

Does this make sense?

[speedydelete]

There are ways to hashlife-optimize single-channel recipes. You can align each sub-recipe to a power of two. For the simeks toolkit, this is very effective because there are only 138 distinct recipes! You also should ensure the spacing between each Snark in the nucleus is a multiple of 16, and that when loading the pattern into Golly, the gliders don't travel on a chunk border.

[dvgrn]

Mostly if we stick with the new-since-2018 crabstretcher method of moving long distances, instead of using the old slow Cordership pushes, and if we keep the DNA in a single diamond-shaped loop instead of packing it into a boustrophedonic nucleus ... then it's going to be sufficiently HashLife-friendly.

Aligning sub-recipes will help with memory use, but only by a relatively small amount: some of the smaller hashtiles will be reusable. But in a big diamond-shaped loop there are really a fairly manageable number of hashtiles anyway. Multiple diamond 0E0P metacells may still be a challenge, but I think Golly will be able to muddle through it fairly well given enough memory.

[Hippo.69]

I am recapitulating what I have already done.
The principle could be seen in routing...

EDIT:
I have removed blocks for testing, then I start testing state reading process (and I forget to return the blocks back) ... so the continuation had no reasonable sense ... now it is corrected.

0e0pcells_routingStateRead.mc

state blocks activated to be read

(209.59 KiB) Downloaded 68 times

The main clock is in "1/2W", global timing is in "(N+W)/2", speedup is in "(N+W)/4" there is probably wrong decision for 0 state ... is should be speeded up 2 mode DNA cycles. ... and SoD should be extended to cover the case traget block waiting for start of neighbour construction remains on its place. ... The SoD would probably require rebuild anyways to be more compatible with new snarkbuilder.

I am thinking about the snark with SoD by glider in opposite direction ... and an independent SoD outside the snark path ... .

Here are my current notes:
See 0e0pcells_routing*.mc ... smaller model (2^24 ticks DNA loop)

Build shell from a SW/NW/NE/SE neighbor, when ready, signal is sent beck to neighbor through "open kernel glider", it redirects DNA from the "after shell build moment" to the newly created shell. The shell entry spiral guarantees the signal comes from all directions synchronized modulo the DNA loop tick count and it builds the oriented shell contents.
The cell clock is started, but not the countdown.
Next loop the DNA transfer from the neighbor is finished (the input continues, but the path is terminated).
Cell already build has prevention from the build attempts from other directions and does not open kernels in those directions.
State signal from a neighbor activates the cell countdown (signals from all 4 neighbors come at essentially same time).

It duplicates some gliders (0 upto 7) from the DNA stream what is time determined by the signals received from the neighbors.
The number of duplicated gliders detemine the future cell state. If it correspond to the dead cell, cell attempts to build neighbours is skipped and the cell "is going to die early"

There are 8 possible states of the cell (according to the number of gliders read) state 0 (no glider read) represents dead cell, states 1-6 (at most 6 gliders read) correspond to in between generation and state 7 (7 gliders read) correspond to living cell of the main (Life) cycle.

(per DNA loop timing):
Dead cell:
1: boats 1,2,3,4,5 activated 3 blocks destroyed, eater destroyed
2: loafblock activated
3: two blocks activated
4: SoD finished, central clock selfdestructed
In between cell:
1: boats 1,2 activated
2: boat 3 activaed
3: boat 4 activated
4: block 1 destroyed
5: block 2 destroyed
6: block 3 destroyed
7: boat 5 activated
8: loafblock activated, eater destroyed
9: two blocks activated
10: SoD finished, central clock selfdestructed
Alive main cell:
1-7: no action
8: boat 1 activated
9: boat 2 activated
10: boat 3 activaed
11: boat 4 activated
12: block 1 destroyed
13: block 2 destroyed
14: block 3 destroyed
15: boat 5 activated
16: loafblock activated, eater destroyed
17: two blocks activated
18: SoD finished, central clock selfdestructed

boat1: opens lane to build NE neighbor
boat2: opens lane to build SE neighbor
boat3: opens lane to build SW neighbor
boat4: opens lane to build NW neighbor
blocks: wait for task completion
boat5: removes the gen from the loop
loafblock: state sent to neighbours, shell SoD invoked
two blocks: SoD of the oriented cell invoked

I am afraid this does not work.
A) 1: Dead cells start constructions of the neighbouring shells and two such construtions can collide
B) 1: In between generations living cells starts construction of both east neighbours in the same time as well making other collisions
Probably Dead cells should activate boat5 during 1: what would prevent the building
In between cells should activate only boat1 during 1: Activate boat 2 at 2 and shift anything after 1: one loop later.

Life to Life ... at 17 in between starts, at 27 new generation starts

(per DNA loop/8 timing internal clock cycle is 2^21, semisnark output 2^22, as DNA loop length would be longer then 2^24, period multiplies should be added/quad snarks used):
From the clock activation (eater output destoyal)
1) state computation started 2) wait 3) semisnark getting ready state comptation finshed (could be affected by distance increase ... semisnark> quadsnark?)
Dead cell:
4) state 0 test OK
6) redirection to 0 state speedup (8 dna loops speedup from in between speedup of the 5th boat is important ... how many gliders would actually proceed to individual constructios?
... Probably best would be to delay the gliders such that there is nothing in the loop between the neighbour lanes openning and the dna circulation stop ...
the start of the neighbor building shell salvo is exactly timed such that 0 state dna circulation stop does not let the first glider went through.
Some dna loop gap should be probably modified to allow dna circulation stop from alive states (are synchronized) to stop it cleanly.
How would it affect SoD? ... We need to destroy the start of construction speboe (in the zero state case/if it remains there)
8 ) state 7 test fail
A) semisnark hit
C) first DNA loop glider going through to wait
C+8) 2nd DNA loop glider going through (to clean the DNA loop + sending the state to neighbors ... no signal)
C+16) 3rd DNA loop glider to shell SoD
In between alive cell:
4) state 0 test fail ... boat removed
6) state 7 test fail
8 ) split to state 1-6 speedup + semisnark hit (6 dna loops speedup from main)
A) first DNA loop glider going through (to allow NE construction)
A+8) 2nd DNA loop glider going through (to allow SE construction)
A+16) 3rd DNA loop glider going through (to allow SW construction)
A+24) 4th DNA loop glider going through (to allow NW construction)
A+32) 5th DNA loop glider going through (to wait)
A+40) 6th DNA loop glider going through (to wait)
A+48) 7th DNA loop glider going through (to wait)
A+56) 8th DNA loop glider going through (to clean the DNA loop)
A+64) 9th DNA loop glider to shell SoD + sending the state to neghbors
A+72) 10th DNA loop glider oriented part SoD
A+80) speedup circuitry removal + gun removal are last parts of SOD job

Alive main cell:
4) state 0 test fail ... boat removed
6) state 7 test OK ... boat removed
8 ) semisnark hit
A) first DNA loop glider absorbed (6 absorber ... main cell could be done to work as inbetween states, but I prefere to let it stay longer switched on ... number of absorbers could be set arbitrary ...)

[Hippo.69]

I've been thinking about how far you could reduce the fixed circuitry of a 0E0P cell. I'm probably missing a lot of details here, but I think you could build a metacell with very little fixed circuitry:

Symmetric components:

1. A splitter/reflector on each corner of the diamond to route the "DNA" around the perimeter of the cell. The reflector should have a transparent lane so that it can accept the DNA from the parent directly from its constructor arm output.
2. A constructor arm on the output of each splitter. The constructor arm is initially blocked with an eater. We also find a "stop codon" recipe which replaces that eater, so we can shut off a constructor arm at any time.
3. 4 programmable master clocks which unblock the constructor arms at specific times.

These were my toughts as well. One problem is you need the DNA loop to be multiple of power 2 ticks.
More importat problem is to transfer the DNA, you should go around the loop and it prolongs the transfer path.
This is why you must add additional turns to gain the time. The design (upto scaling) I have provided creates such turns and lets antiparalel streams of gliders be almost as far as possible.

Non-symmetric components:

1. The programs for the master clocks.

Why I *think* this would work:

1. We can construct daughter cells one at a time by unblocking the construction arms in sequence.
2. We can divide construction into multiple steps with a stop codon, e.g., start crabstretcher, *stop*, unblock again, burn the fuse, build the rest.
3. We can ensure the DNA is the same phase in all daughter cells by choosing where to start the copy. We start copying with a delete elbow recipe, and we end copying by intercepting the stream with a master clock glider and recovering the elbow. We would have four copies of the sequence "delete elbow, recover elbow from crossing glider" in the stream, equally spaced.
4. To achieve asymmetry, we have 4 different recipes to build temporary snarks to move the construction arm to different orientations before sending the recipe for the master clock programs.
5. (Big handwaving) the construction arm can do the state calculations. E.g., we find recipes that detect gliders from the neighbor cells, store data in offset blocks, and send signals to the other cells. The lookup table may become 4096 recipes instead of 4096 gliders, but maybe it works out to be similarly efficient since one-time circuitry is much simpler.

The clock synchronization could be easily achieved by letting the directed program to hit the start construction speboe at the same tick mod the DNA loop. I am not sure there should be any pauses, I would like to use delay times in one construction to work else where (between sending the crab and igniting the fuse)...

I am not sure I got the idea with 4 diferent recipes. How do you want to chose which recipe would be used? I still expect we are building given protion of the cell by a fixed part of the DNA.

... Yes there is inefficiency in the shell that there are 3/4 unused inputs and similarly 3/4 of the input paths are not used ... this is why the shell is made as light as possible. But all 4 neighbous use the same recipe to build the entire cell. Alternative to use 4 smaller shells to be build by 4 diferent recipes with some specialised cutting of the required part of the DNA could work as well, but I am afraid the corresponding total DNA length would be very similar to the "current version".

Morever the SoD required at the end of cell life is much easier when the cell is almost the same independently on the direction of the build,
currenty the only differences are in entrance stoppers where there is one block missing when the cell was built by another neighbor (this conditional block is rather isolated so one glider and one nearby block whose destruction spark cleans it is one glider cheaper SoD for this case).
The shell prevents builds from other direction. Building by different paths should somehow detect the situation ... but I am afraid the variability which should SoD solve depending on the set of living neighbors will be too hard to manage.

Code: Select all

x = 154, y = 63, rule = DoubleB3S23
2C$2C21$143.2C$143.2C5$23.2A113.2A$23.2A113.2A3$151.2C$151.C.C$151.C
9$48.C$47.C.C$48.C.C$49.2C5$40.2C$39.C2.C$40.C.C$41.C6$38.2C$37.C.C$
39.C!

The oriented part of the cell thanks to exact synchronization can use the same DNA part in all cases.

Problems:

1. Would this be hashlife efficient?
2. The clock needs a large dynamic range -- it needs to send gliders exactly timed in times smaller than the period of the glider loop, including a repeat time smaller than the period of the loop, but also be able to wait for multiple loops, especially if there's a long "look like a cell" phase.
3. Efficiently packing the recipes into the DNA so that we can trigger them when needed and don't have to leave wide gaps or wait full cycles for things to come around again.
4. All the other things I haven't considered that would be blockers.

Does this make sense?

Definitely the waste time distances complicate the construction a lot. You can see the 2^19 main clock…

I hope my previous post answers a lot of questions and of course ... I am ready to discuss alternatives.


The design consists of a lot of small islands far away.
We can see groups of them around aW/4+bN/4 (with fixed relative positions) coordinates for small absolute values of a and b.

First job of the construction is to create targets in each group location… this would be the double crab double stretcher goal with glider pairs or glider with xwss collisions task…

I do not know how small the exponent in the cell size will finally be. The scheme is scalable, just the central clock would require more frequency dividers…

[russellsprouts]

I'm having trouble opening the routingStateRead.mc file in Golly 5.0. It says

Code: Select all

File could not be loaded by any algorithm.

Error from HashLife:
Bad character found.

Error from QuickLife:
Cannot read macrocell format.

Error from Generations:
Bad character found.

Error from Larger than Life:
Cannot read macrocell format.

Error from JvN:
This algorithm only supports these rules:
JvN29, Nobili32, Hutton32.

Error from Super:
Missing Super, History or Investigator postfix.

Error from RuleLoader:
Unknown rule: LifeHistory14

These were my toughts as well. One problem is you need the DNA loop to be multiple of power 2 ticks.
More importat problem is to transfer the DNA, you should go around the loop and it prolongs the transfer path.
This is why you must add additional turns to gain the time. The design (upto scaling) I have provided creates such turns and lets antiparalel streams of gliders be almost as far as possible.

Oh, yes I understand. I was thinking that if the DNA is ABCD, you could copy BCDA or CDAB to fix the phasing. But that doesn't work -- it doesn't matter when you start and stop, because you'll always be copying the DNA into the East corner when it should be in the North corner, for example. You need to have a different path for it to gain or lose time to line up.

I am not sure I got the idea with 4 diferent recipes. How do you want to chose which recipe would be used? I still expect we are building given protion of the cell by a fixed part of the DNA.

So imagine the DNA is divided into separate segments, The full build sequence could look like: BUILD_SYMMETRIC_SHELL, stop codon, ARM_ROTATE90, ARM_ROTATE90, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE.

Each arm would be activated at the right time so that the BUILD_SYMMETRIC_SHELL recipe has reached it, it will build it, then it will deactivate. We send a second activation with a slightly different timing on each arm, so that we build the asymmetric portion in the same orientation each time.

• BUILD_SYMMETRIC_SHELL, BUILD_ASYMMETRIC_PIECE
• BUILD_SYMMETRIC_SHELL, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE
• BUILD_SYMMETRIC_SHELL, ARM_ROTATE90, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE
• BUILD_SYMMETRIC_SHELL, ARM_ROTATE90, ARM_ROTATE90, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE

So, no matter which side we are building, we can correct for the orientation and build the asymmetric piece right side up.

[Hippo.69]

I'm having trouble opening the routingStateRead.mc file in Golly 5.0. It says

Code: Select all

File could not be loaded by any algorithm.

Error from HashLife:
Bad character found.

Error from QuickLife:
Cannot read macrocell format.

Error from Generations:
Bad character found.

Error from Larger than Life:
Cannot read macrocell format.

Error from JvN:
This algorithm only supports these rules:
JvN29, Nobili32, Hutton32.

Error from Super:
Missing Super, History or Investigator postfix.

Error from RuleLoader:
Unknown rule: LifeHistory14

I am not near my computer, I will give the rule definitions and convertors. Having plain life file would lose too much info…
I still am not sure with the salvo selection, it would be hard to incorporate the timing…

So imagine the DNA is divided into separate segments, The full build sequence could look like: BUILD_SYMMETRIC_SHELL, stop codon, ARM_ROTATE90, ARM_ROTATE90, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE.

Each arm would be activated at the right time so that the BUILD_SYMMETRIC_SHELL recipe has reached it, it will build it, then it will deactivate. We send a second activation with a slightly different timing on each arm, so that we build the asymmetric portion in the same orientation each time.

• BUILD_SYMMETRIC_SHELL, BUILD_ASYMMETRIC_PIECE
• BUILD_SYMMETRIC_SHELL, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE
• BUILD_SYMMETRIC_SHELL, ARM_ROTATE90, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE
• BUILD_SYMMETRIC_SHELL, ARM_ROTATE90, ARM_ROTATE90, ARM_ROTATE90, BUILD_ASYMMETRIC_PIECE

So, no matter which side we are building, we can correct for the orientation and build the asymmetric piece right side up.

I am not sure what you want to achieve ... what BUILD_SYMMETRIC_SHELL means? Are there 4 diferent entry points dependent on the DNA fill direction (expecting the building neighbor would fill it) so spiral with 4 paths with just one would be used?
This does not seem to be compatible with the ARM_ROTATE90 idea.

I would interpret the ARM_ROTATE90 idea as you want to build the cell from its center and depending on the build direction you have to bend the input glider stream 0 upto 3 times. In that case you do not need the shell at all. Unfortunately it would be very difficult to avoid collisions with the input glider stream especially as there would be 4 virtual streams you should avoid simultaneously.

To finish the build in all 4 cases at the same tick mod the DNA loop period would require the last bend on each input path "to be finished" at the same tick (mod DNA loop period). It looks much more complicated then the shell with 4 input paths solution.

[Anivec]

I am not near my computer, I will give the rule definitions and convertors. Having plain life file would lose too much info…
I still am not sure with the salvo selection, it would be hard to incorporate the timing…

Can you just use LifeHistory so that nobody else has to download the rule table?

[Hippo.69]

I am not near my computer, I will give the rule definitions and convertors. Having plain life file would lose too much info…
I still am not sure with the salvo selection, it would be hard to incorporate the timing…

Can you just use LifeHistory so that nobody else has to download the rule table?

That would make the pattern less readable (I am missing distingtion of the origin of the dead states so snapshots say less about history). Currently the code generating the pattern uses more states... Converting to LifeSuper would be an alternative, but I am not familiar with it (I have used it recently in debugging long slow salvas to distinguish milestone gliders, but I am not sure how good is it for imobile patterns).
I have actualized https://github.com/Hippo-69/CGoL_0e0p_optimization, there are now also rules and usefull conversions (in the same directory).
May be this is just a small difference ... (here dead SoD states are missing)

StateReadingLH.png (20.11 KiB) Viewed 2927 times

StateReading.png (21.67 KiB) Viewed 2927 times

[Hippo.69]

Code: Select all

x = 31, y = 39, rule = LifeHistory
$26.A$26.A.A$26.2A7$5.2A$6.A$4.A$4.5A14.2A$9.A13.A$6.3A12.A.A$5.A15.
2A$5.4A$3.2A3.A3.2A$2.A2.3A4.2A$2.2A.A$5.A$5.2A3$13.2A$4.C9.A$3.C.C5.
3A$3.C2.C4.A$4.2C$17.C$16.C.C$16.C2.C$17.2C2$3.2C$2.C.C$3.C!

Here's a result from GoL_destroy

Oh thanks ... better one ... I have not noticed you can ask for output glider on a specified lane in GoL_destroy.
I do not think we can end up with something much cheaper to build so for SoD builds ... this is probably the pattern which could become very handy to have fast single lane recipe for. (Of course building from the snark input lane and creating speboe on its output lane which would not interact with the pattern. There is definitely tradeoff in small envelope size for usability and salvo build time.)

For 0e0pmetacell, I would gladly modify spacing between islands in the pattern to allow build by an optimized SnarkSoDBuilder (and I would not work on it till the reaction envelope of the builder would be fixed (reasonable upper bound)).

Actually as the pattern is computed, doing the changes would be reasonably easy.

It would require some care to be sure all 4 paths from cell to its neighbour shells till the oriented build start construction remain equally long, but this is definitely worth the speedup.
It probably would not be problem if the final stages of SnarkSoDBuilder would leave some (small ... reasonably distant) junk near the output path (or at least we would use such modifications). Sometimes we would like to construct something else then the construction path itself ... and having handy targets for the construction ... .

[russellsprouts]

FWIW, I implemented an autoshrink command in the search tool, so finding additional a recipe which adds the additional pieces could be a much smaller search. You could start with a truncated version of the recipe before cleanup is complete, "print" the SOD pieces in place by finding partial_intermediate matches (a few rounds of searches and manually choosing which candidates to pick for the next round), then run autoshrink until it finds the cleanup (may take a day or two depending on your parameters)

[Hippo.69]

FWIW, I implemented an autoshrink command in the search tool, so finding additional a recipe which adds the additional pieces could be a much smaller search. You could start with a truncated version of the recipe before cleanup is complete, "print" the SOD pieces in place by finding partial_intermediate matches (a few rounds of searches and manually choosing which candidates to pick for the next round), then run autoshrink until it finds the cleanup (may take a day or two depending on your parameters)

Thanks, I should definitely start learning how to use your program .
Current task I have in mind is to modify the 0e0p metacell ... SoD to be ready for the input path destructions by the glider in the opposite direction.
There are other tasks on the way (the construction entrances should be destroyed). One way would be to modify snark SoD to fire an additional output (used only on some snarks), but probably better alternative would be to use the input scorbie reflector (what would be modified to be destroyed by the glider in the opposite direction to its output (finishing the snarks path)) ... the SoD would output glider to destroy scorbie insertor 2nd on another input path, 3rd on yet another input path and fourth on the last input path ... then the destruction signal could continue to deal with construction inputs.

Hmmm ... now I maybe become inspired by your toughts about the build. It seems to me we can divide the construction to the following phases:

1) From the construction corner allocate roughly all regions where the construction should continue.
2) Having the targets send (slow^2?) salvas to arrange the targets to exact rotationaly symmetric coordinates (to be chosen),
build the shell entry prevention on all 4 corners.
3) build whole spiral lane starting from the construction corner, the spiral would include all the scorbie insertors
4) bend temporarrily inner end if the spiral to reach conterclockwise next corner and start building next spiral lane
5) at the end of second spiral lane bend to build third and then fourth spiral lane.
6) After finishing the 4th spiral open the kernel to start inner construction.

It is natural to reuse 4 times the same DNA subsequence as the spiral lanes are all the same.
There are few technical problems/decisions to be made the solution have ... the first input scorbie should have SoD on its transparent input lane (The question is will we start the construction at the snark after it, so we should build this scorbie insertor separately? Other option is to start one turn earlier with a temporary snark ... )
We definitely should destroy the bends connecting i-th path to the start of i+1st, fifth bending slightly differ from the previous.
How we differentiate the programs. How we destroy the temporary bends between the spiral parts?

I have no problem to let the live of the cell be 3 DNA loops longer when it comes with the radical DNA loop content shortening.

The main clock timing could remain very simillar to the current idea ... the builds of neighbouring cells would start at the consecutive DNA loops to be sure the shell entrance mechanisms are build just from one direction. Then all neighbours whose entrance was opened by watched cell would be receiving the DNA build program in parallel, being 0,1,2,3 DNA loops delayed, when all 4 shell spirals of a nighbouring cell are completed, the kernel entrance is opened ... what builds the directed shell and starts inner clock (sending tick gliders to an eater).
Exactly after 3 DNA loops after the first clocks are started the 4th (if build by the watched cell) neighbor inner clocks are started.
A DNA loop later SoD of watched cell is started, what as first sends its state to the neighbors, what destroys eaters at outputs of their inner clocks, so the next generation is started in sync by next state part of DNA reading.

This use of 4 DNA loops to build shell spirals could shorten the DNA length if we manage to conditionaly switch part of the DNA interpreting of.
(If we do not manage it, we could repeat the corresponding subsequence 4 times ... so the small differences in bending between the consecutive parts will be easier to implement. In all cases this will simplify the build as we would not need to compute different subprograms ...

This would perfectly itilize the in envelope recepies when we would build mostly along the path.

Considering the oriented build, most of it is again a closed loop so building it mostly along the path would be good strategy as well.
There central clocks is probably the only part which will be built mostly by classical 0/90 degree speboe technology.

... so any ideas how to manage the DNA switching off/on during the build?

Would do the oriented construction through all 4 spirals? Probably not ...
Would we destroy the spiral parts connections from the end of the 4th spiral?
I don't know, we definitely could ... the portion of the DNA which source would be cut ... would be much longer then is necessary to manage the change of all the interconnections. We just probably want to open the kernel at the start of the directed build portion such that when the signal cames to the end of the first spiral, there are no interfering spiral connections.

Probably simillar build along the path could be used along the scorbie splitters ... just one of its outputs must be closed by an eater and we should build "SoD" path to the eater to be able to swith to construction of the closed branch (while closing the other ... to be woked up at the right moment) ... (State distribution to the neighbors subcircuit is an example of use, but the DNA filling path/ DNA loop path another..., but there is a lot of to do before starting the oriented cell build programming)

I used this problem -- state 2 restricts the envelope of the reaction, so only a result which sends a glider on the right lane would destroy the block.

Code: Select all

x = 145, y = 187, rule = LifeHistory
6$97.B$96.2B$95.3B$94.4B$93.4B$92.4B$91.4B$90.4B$89.4B$88.4B$87.4B$
86.4B$85.4B$84.4B$83.4B$82.4B$81.4B$80.4B$79.4B$78.4B$77.4B$76.4B$75.
4B$74.4B$73.4B$72.4B$71.4B$70.4B$69.4B$68.4B$67.4B$66.4B$65.4B$64.4B$
63.4B$62.4B$61.4B$60.4B$59.4B$58.4B$57.4B$56.4B$55.4B$54.4B$53.4B$52.
4B$51.4B$50.4B$49.4B$48.4B$47.4B$46.A3B$18.9B18.BABA$15.18B11.2B2A$
12.24B7.4B$11.27B4.4B$9.31B.4B$8.36B$8.35B$7.36B$6.38B$6.37B3D$5.37B
5D$5.36B7D$4.36B9D$4.35B11D$4.35B12D$3.15B2A19B13D$3.16BA19B14D$3.14B
A22B14D$3.14B5A14B2A2B15D$3.19BA13BA3B16D$2.17B3A12BABA3B17D$2.16BA
15B2A3B19D$2.16B4A17B20D$2.14B2A3BA3B2A11B22D$2.13BA2B3A4B2A9B25D$2.
13B2ABA18B25D$2.16BA19B25D$2.16B2A19B25D$3.37B25D$3.10B3D25B25D$3.9B
5D9B2A14B25D$3.8B7D9BA15B25D$3.7B9D5B3A3B4D10B24D$4.6B10D4BA5B5D10B
23D$4.5B12D8B7D10B21D$5.4B13D5B10D10B19D$6.2B30D10B17D$7.B31D10B15D$
8.32D10B13D$9.32D10B11D$10.32D10B9D$11.32D10B7D$11.33D10B5D$12.33D10B
3D$14.32D10B$15.32D8B$16.32D7B$17.32D7B$18.32D2B.4B$19.30D5.4B$20.27D
8.4B$21.25D10.4B$22.22D13.4B$23.20D15.4B$24.18D17.4B$25.16D19.4B$26.
13D22.4B$27.11D24.4B$28.9D26.4B$28.7D29.4B$29.5D31.4B$30.3D33.4B$67.
4B$68.4B$69.4B$70.4B$71.4B$72.4B$73.4B$74.4B$75.4B$76.4B$77.4B$78.4B$
79.4B$80.4B$81.4B$82.4B$83.4B$84.4B$85.4B$86.4B$87.4B$88.4B$89.4B$90.
4B$91.4B$92.4B$93.4B$94.4B$95.4B$96.4B$97.4B$98.4B$99.4B$100.4B$101.
4B$102.4B$103.4B$104.4B$105.4B$106.4B$107.4B$108.4B$109.4B$110.4B$
111.4B$112.4B$113.4B$114.4B$115.4B$116.4B2.3B$117.11B$118.10B$119.10B
$120.9B$120.4B2A3B$120.4B2A3B$120.9B$120.9B$120.9B!

Oh clever way to do so.

[speedydelete]

I think we should definitely be using single channel with minimum spacing 61 (sc61) also with some of the new p120 toolkit for this. Even if we have to use Extremely Inefficient clock inserter based stuff, I still think it's worth it.

Also, I am maybe going to work on a "slmake v2" now that I have finished the single-channel searcher (more about that soon!).

Edit: We can also use a p46 version (which prohibits only 3 out of the 46 possible timing gap sums!), but perhaps it is worth it to build the beehive push catalyst anyway (this was devised by me, lumi, and TigerCub414 on Discord):

Code: Select all

x = 94, y = 93, rule = LifeHistory
14.A$12.3A$11.A$11.2A10.2A$23.A19.2A$2A19.A.A18.A.A$.A19.2A19.A$.A.A37.
2A$2.2A46.2A$49.A.A$50.A2$2.2A$.A.A18.D15.2A3.D$.A18.D.D15.2A2.2D$2A4.
2A12.3D18.2D11.2D$5.A.A12.D21.D10.2D$5.A37.D10.D$4.2A2$20.2A$20.2A3.A
$24.A.A$25.A.A$27.A$27.2A23.2A$51.A2.A$51.A.A$52.A$48.2A$49.A$46.3A14.
2A$46.A16.A.A$65.A$65.2A6$47.2A3.3D7.2A$47.2A4.D8.A.A$53.3D8.A$64.2A$
46.A$45.A.A$46.A$43.3A$43.A4$43.A8.2A$43.3A6.2A$46.A$39.2A4.2A$40.A$40.
A.A$41.2A32.2A$58.2A14.A.A15.2A$44.2A11.A2.A13.A17.2A$43.A2.A11.2A14.
3A$38.2A4.A.A$38.2A5.A2$74.3A$36.2A5.2A20.2A7.A$36.A2.A.A2.A20.2A7.A.
A$37.3A.3A31.2A$40.A$37.2A2.A$36.A2.2A$36.2A3$61.3A$61.A$62.A13$77.2A
$76.2A$78.A!

Why not use NW31? That's sc70.

There should only be one splitter in the full 0E0P design right? The rest can just be Snarks.

[Anivec]

I think we should definitely be using single channel with minimum spacing 61 (sc61) also with some of the new p120 toolkit for this. Even if we have to use Extremely Inefficient clock inserter based stuff, I still think it's worth it.

Code: Select all

x = 94, y = 93, rule = LifeHistory
14.A$12.3A$11.A$11.2A10.2A$23.A19.2A$2A19.A.A18.A.A$.A19.2A19.A$.A.A37.
2A$2.2A46.2A$49.A.A$50.A2$2.2A$.A.A18.D15.2A3.D$.A18.D.D15.2A2.2D$2A4.
2A12.3D18.2D11.2D$5.A.A12.D21.D10.2D$5.A37.D10.D$4.2A2$20.2A$20.2A3.A
$24.A.A$25.A.A$27.A$27.2A23.2A$51.A2.A$51.A.A$52.A$48.2A$49.A$46.3A14.
2A$46.A16.A.A$65.A$65.2A6$47.2A3.3D7.2A$47.2A4.D8.A.A$53.3D8.A$64.2A$
46.A$45.A.A$46.A$43.3A$43.A4$43.A8.2A$43.3A6.2A$46.A$39.2A4.2A$40.A$40.
A.A$41.2A32.2A$58.2A14.A.A15.2A$44.2A11.A2.A13.A17.2A$43.A2.A11.2A14.
3A$38.2A4.A.A$38.2A5.A2$74.3A$36.2A5.2A20.2A7.A$36.A2.A.A2.A20.2A7.A.
A$37.3A.3A31.2A$40.A$37.2A2.A$36.A2.2A$36.2A3$61.3A$61.A$62.A13$77.2A
$76.2A$78.A!

Reduction like you asked for. (Loaf has about 10^13 more occurrences than boat, making it cheaper in theory)

Code: Select all

x = 101, y = 91, rule = LifeHistory
21.A$19.3A8.A$18.A9.3A19.2A$18.2A7.A21.A.A$27.2A20.A$48.2A$65.2A$64.A
2.A$64.A.A$65.A2$29.D15.2A3.D$2A11.A13.D.D15.2A2.2D$2A10.A.A12.3D18.2D
11.2D$12.A2.A11.D21.D10.2D$13.2A35.D10.D2$16.2A$16.A.A8.2A$18.A8.2A3.
A$18.2A11.A.A$32.A.A$34.A$34.2A23.2A$58.A2.A$58.A.A$59.A$55.2A$56.A$53.
3A14.2A$53.A16.A.A$72.A$72.2A6$54.2A3.3D7.2A$54.2A4.D8.A.A$60.3D8.A$71.
2A$53.A$52.A.A$53.A$50.3A$50.A4$50.A8.2A$50.3A6.2A$53.A$46.2A4.2A$47.
A$47.A.A$48.2A32.2A$65.2A14.A.A15.2A$51.2A11.A2.A13.A17.2A$50.A2.A11.
2A14.3A$45.2A4.A.A$45.2A5.A2$81.3A$43.2A5.2A20.2A7.A$43.A2.A.A2.A20.2A
7.A.A$44.3A.3A31.2A$47.A$44.2A2.A$43.A2.2A$43.2A3$68.3A$68.A$69.A13$84.
2A$83.2A$85.A!

[Hippo.69]

I think we should definitely be using single channel with minimum spacing 61 (sc61) also with some of the new p120 toolkit for this. Even if we have to use Extremely Inefficient clock inserter based stuff, I still think it's worth it.

Also, I am maybe going to work on a "slmake v2" now that I have finished the single-channel searcher (more about that soon!).

Edit: We can also use a p46 version (which prohibits only 3 out of the 46 possible timing gap sums!), but perhaps it is worth it to build the beehive push catalyst anyway (this was devised by me, lumi, and TigerCub414 on Discord):

Code: Select all

x = 94, y = 93, rule = LifeHistory
14.A$12.3A$11.A$11.2A10.2A$23.A19.2A$2A19.A.A18.A.A$.A19.2A19.A$.A.A37.
2A$2.2A46.2A$49.A.A$50.A2$2.2A$.A.A18.D15.2A3.D$.A18.D.D15.2A2.2D$2A4.
2A12.3D18.2D11.2D$5.A.A12.D21.D10.2D$5.A37.D10.D$4.2A2$20.2A$20.2A3.A
$24.A.A$25.A.A$27.A$27.2A23.2A$51.A2.A$51.A.A$52.A$48.2A$49.A$46.3A14.
2A$46.A16.A.A$65.A$65.2A6$47.2A3.3D7.2A$47.2A4.D8.A.A$53.3D8.A$64.2A$
46.A$45.A.A$46.A$43.3A$43.A4$43.A8.2A$43.3A6.2A$46.A$39.2A4.2A$40.A$40.
A.A$41.2A32.2A$58.2A14.A.A15.2A$44.2A11.A2.A13.A17.2A$43.A2.A11.2A14.
3A$38.2A4.A.A$38.2A5.A2$74.3A$36.2A5.2A20.2A7.A$36.A2.A.A2.A20.2A7.A.
A$37.3A.3A31.2A$40.A$37.2A2.A$36.A2.2A$36.2A3$61.3A$61.A$62.A13$77.2A
$76.2A$78.A!

Why not use NW31? That's sc70.

There should only be one splitter in the full 0E0P design right? The rest can just be Snarks.

I am not sure how much would we gain by sc61/sc70, but we definitely need more then one splitter.
And we would definitely need transparent lane insertor (to fill the prepeared DNA loop).
Current design requires shell with 4 insertors on all of its 4 sides.
We need a splitter to get the compute the next state part of DNA, we need 3 splitters to send state to neighbors.
(Currently we use temporary splitter in the cell allocation ... sending 2 crabs 2 stretchers in parallel ...)

I am not sure how much "neo spartan" your nontransparent splitter is, probably bespoke extensions to pslmake would be required to find a slow salvo for it. We would also lose a lot of hash friendliness using longer periods in the circuitry (excluding powers of two).

So we have to consider the gains from the faster circuits compared to loses caused by increased costs of the new replacement circuitry.

Have you watched the cell idea presented in

?

We could replace individual subcuircuits, their SoD's, but the subcircuits goals must be achieved.
... we need a DNA loop with period 2^X ... we should transfere DNA to it from a neighbouring cell, we should build it from any of 4 possible neighboring cells, we should prevent crash of constructions/transfers from 2 different neighbours.
We need a central clock aging the cell.
We should get states from all 4 neighbors and compute new state according the DNA inforamtion addressed by the states. (We have 1 dead state (no signal transfered) 1 life alive state and 6 inbetween states. The rules for inbetween states are assymetric (and not all 6^4 state combinations are possible (less then 2^9)).

Calcymans (apg's) design was to build 4 spirals to synchronize the streams of gliders from cell neighbors at the same tick at the same place in the directed cell (upto DNA loop length). He used much longer spirals that is needed, but I have no better idea how to build the oriented cell independently from all 4 neighbors.

Build from more then one neighbour is prevented by using 0 degree arm move 44 on the cell entrance, where a single block prevents creating speboe so it is conditionaly delete rather to move44. Eater behind the entrance is therefore not colliding with the (now stopped) recipe and all the glider stream is cleanly eaten (even on following DNA loops).

(If there is no neighbor on the side, the block preventing the entrance would remain on place, so SoD of the cell should get rid of this conditional block.)

Simillar conditional blocks appear at the start of the neighbor builds, as state 0 skips building neighbors and dies instead. So the speboes ... to be moved to the borders of the neighbor cell would conditionally remain on the original place.

Other conditional subcircuits are used when build of neighbor opens kernel path to it. (Stopped neigbor does not open it, so SoD should conditionaly destroy the path ...)

[russellsprouts]

... so any ideas how to manage the DNA switching off/on during the build?

Maybe we can clean up this reaction:

Code: Select all

x = 150, y = 152, rule = LifeHistory
$.2A$.2A3$.3A$.A$2.A18$21.2D$22.D$22.D.D$23.2D10$36.A$35.2A$35.A.A21$
58.2A$57.2A$59.A38$97.3A$97.A$98.A44$145.A$144.2A$144.A.A!

Edit: I wasn't even searching for it, but the far block is a PI block, so it can work as the next elbow!

[Hippo.69]

... so any ideas how to manage the DNA switching off/on during the build?

Maybe we can clean up this reaction:

Code: Select all

x = 150, y = 152, rule = LifeHistory
$.2A$.2A3$.3A$.A$2.A18$21.2D$22.D$22.D.D$23.2D10$36.A$35.2A$35.A.A21$
58.2A$57.2A$59.A38$97.3A$97.A$98.A44$145.A$144.2A$144.A.A!

Edit: I wasn't even searching for it, but the far block is a PI block, so it can work as the next elbow!

This builds a dirty eater so it stops all the single lane salvo directed there. I do not know which logic it provides.

The switching for the case of shell build by 4 loops should somehow interrupt the single lane recipe (eater would work well) but we need to restore the build just before the next DNA portion doing the construction starts.
I do not know if something reasonable for our purposes work ... build a rather cheap pattern which would explode by some phase modulated glider signal ... which does not appear else in the DNA (and goes cleanly through the DNA loop)? ...
If we need to build another path from otts to "destroy the eater" which would be triggered by central clock of parrent cell ... it could become expensive ... (especially the synchronization).

Building the shell by spiral paths prepares us for the case the cheap conditional recipe switching would appear, but till that time we expect to use 4 almost consecutice identical recipes (without switching needs).

What could work is having separate portion of the DNA be cut in parent cell circling with eater blocked outputs to all neighboring cells. After building shell entrance blockers the eater would be destroyed what will be sending only the subrecipe … the shell neednot be buld in sync for all neighbors… I do not think it would be good idea to copy shell building DNA portion separately. That would case synchronization problems. There is one possibility… to cut it during each DNA loop/cut it once and let it circle. The first method would have relative to DNA constant delays (slightly different depending to the direction). Disadvantage is the on-off switcher should be “permanent” … is direction switching of apg´s unidimensional ship ecca1 fast enough?


There is currently the DNA split to statereading mechanism, as the statereading is done much earlier, we can use the stream to cut spiral build portion from it…
But I am afraid the construction of the oriented portion would be much more expensive, that shortening the shell build could be contraproductive…

[Anivec]

Edit: We can also use a p46 version (which prohibits only 3 out of the 46 possible timing gap sums!), but perhaps it is worth it to build the beehive push catalyst anyway (this was devised by me, lumi, and TigerCub414 on Discord):

Code: Select all

x = 94, y = 93, rule = LifeHistory
14.A$12.3A$11.A$11.2A10.2A$23.A19.2A$2A19.A.A18.A.A$.A19.2A19.A$.A.A37.
2A$2.2A46.2A$49.A.A$50.A2$2.2A$.A.A18.D15.2A3.D$.A18.D.D15.2A2.2D$2A4.
2A12.3D18.2D11.2D$5.A.A12.D21.D10.2D$5.A37.D10.D$4.2A2$20.2A$20.2A3.A
$24.A.A$25.A.A$27.A$27.2A23.2A$51.A2.A$51.A.A$52.A$48.2A$49.A$46.3A14.
2A$46.A16.A.A$65.A$65.2A6$47.2A3.3D7.2A$47.2A4.D8.A.A$53.3D8.A$64.2A$
46.A$45.A.A$46.A$43.3A$43.A4$43.A8.2A$43.3A6.2A$46.A$39.2A4.2A$40.A$40.
A.A$41.2A32.2A$58.2A14.A.A15.2A$44.2A11.A2.A13.A17.2A$43.A2.A11.2A14.
3A$38.2A4.A.A$38.2A5.A2$74.3A$36.2A5.2A20.2A7.A$36.A2.A.A2.A20.2A7.A.
A$37.3A.3A31.2A$40.A$37.2A2.A$36.A2.2A$36.2A3$61.3A$61.A$62.A13$77.2A
$76.2A$78.A!

Here is one more, construct at your own risk.

Code: Select all

x = 63, y = 102, rule = LifeHistory
9.2A$10.A$7.3A$7.A$12.2A$11.A.A$11.A$10.2A$9.A$10.2A$11.A$10.A$11.3A$
13.A4$27.2A$26.A2.A$26.A.A$27.A3$.A$A.A$A.A$.A3$9.2A$2A7.2A$2A3$21.2A
$20.A2.A$20.A.A$21.A$17.2A$18.A$15.3A14.2A$15.A16.A.A$34.A$34.2A6$16.
2A3.3D7.2A$16.2A4.D8.A.A$22.3D8.A$33.2A$15.A$14.A.A$15.A$12.3A$12.A4$
12.A8.2A$12.3A6.2A$15.A$8.2A4.2A$9.A$9.A.A$10.2A32.2A$27.2A14.A.A15.2A
$13.2A11.A2.A13.A17.2A$12.A2.A11.2A14.3A$7.2A4.A.A$7.2A5.A2$43.3A$5.2A
5.2A20.2A7.A$5.A2.A.A2.A20.2A7.A.A$6.3A.3A31.2A$9.A$6.2A2.A$5.A2.2A$5.
2A3$30.3A$30.A$31.A13$46.2A$45.2A$47.A!

What is the extra block for?

Code: Select all

x = 94, y = 93, rule = LifeHistory
14.A$12.3A$11.A$11.2A10.2A$23.A19.2A$2A19.A.A18.A.A$.A19.2A19.A$.A.A37.
2A$2.2A46.2A$49.A.A$50.A2$2.2A$.A.A18.D15.2A3.D$.A18.D.D15.2A2.2D$2A4.
2A12.3D18.2D11.2D$5.A.A12.D21.D10.2D$5.A37.D10.D$4.2A2$20.2A$20.2A3.A
$24.A.A$25.A.A$27.A$27.2A23.2A$51.A2.A$51.A.A$52.A$48.2A$49.A$46.3A14.
2A$46.A16.A.A$65.A$65.2A6$47.2A3.3D7.2A$47.2A4.D8.A.A$53.3D8.A$64.2A$
46.A$45.A.A$46.A$43.3A$43.A4$43.A8.2A$43.3A6.2A$46.A$39.2A4.2A$40.A$40.
A.A$41.2A32.2A$58.2A14.A.A15.2A$44.2A11.A2.A13.A17.2A$43.A2.A11.2A14.
3A$38.2E4.A.A$38.2E5.A2$74.3A$36.2A5.2A20.2A7.A$36.A2.A.A2.A20.2A7.A.
A$37.3A.3A31.2A$40.A$37.2A2.A$36.A2.2A$36.2A3$61.3A$61.A$62.A13$77.2A
$76.2A$78.A!

EDIT
Transparent lanes:

Code: Select all

x = 402, y = 106, rule = LifeHistory
14.2A$14.A$12.A.A$12.2A$8.A16.A$7.A.A7.2A4.3A$7.A.A6.A.A3.A$8.A8.A4.2A
$312.A$311.A.A$167.2A142.A.A$167.2A140.3A.2A$308.A$309.3A.2A$2A309.A.
2A$2A154.2A$31.2A124.A23.2A148.2A$31.A19.2A104.A.A21.A19.2A128.A19.2A
$29.A.A18.A.A105.2A19.A.A18.A.A126.A.A18.A.A$29.2A19.A128.2A19.A128.2A
19.A$49.2A148.2A148.2A$7.2A49.2A148.2A148.2A$8.A48.A.A147.A.A147.A.A$
5.3A50.A149.A149.A$5.A2$30.D15.2A3.D128.D15.2A3.D128.D15.2A3.D$28.D.D
15.2A2.2D126.D.D15.2A2.2D126.D.D15.2A2.2D$28.3D18.2D11.2D114.3D18.2D11.
2D114.3D18.2D11.2D$28.D21.D10.2D115.D21.D10.2D115.D21.D10.2D$51.D10.D
138.D10.D138.D10.D$167.2A$163.2A2.2A$20.A7.2A132.A.A13.2A148.2A$13.2A
4.A.A6.2A3.A128.A15.2A3.A135.A8.2A3.A$13.2A5.A11.A.A126.2A19.A.A133.A
.A11.A.A$33.A.A147.A.A132.A.A12.A.A$24.2A9.A149.A133.A15.A$19.2A3.2A9.
2A23.2A123.2A23.2A101.2A20.2A23.2A$12.2A5.2A38.A2.A146.A2.A100.2A44.A
2.A$11.A.A45.A.A147.A.A147.A.A$9.3A.A.A44.A149.A149.A$8.A5.2A40.2A148.
2A103.2A43.2A$8.2A47.A149.A102.A.A44.A$54.3A14.2A131.3A14.2A87.A43.3A
14.2A$54.A16.A.A130.A16.A.A85.2A43.A16.A.A$73.A149.A149.A$73.2A148.2A
148.2A6$55.2A3.3D7.2A133.2A3.3D7.2A133.2A3.3D7.2A$55.2A4.D8.A.A132.2A
4.D8.A.A132.2A4.D8.A.A$61.3D8.A138.3D8.A138.3D8.A$72.2A148.2A148.2A$54.
A149.A149.A$53.A.A147.A.A147.A.A$54.A149.A149.A$51.3A147.3A147.3A$51.
A149.A149.A4$51.A8.2A139.A8.2A139.A8.2A$51.3A6.2A139.3A6.2A139.3A6.2A
$54.A149.A149.A$47.2A4.2A142.2A4.2A142.2A4.2A$48.A149.A149.A$48.A.A147.
A.A147.A.A$49.2A32.2A114.2A32.2A114.2A32.2A$66.2A14.A.A15.2A114.2A14.
A.A15.2A114.2A14.A.A15.2A$52.2A11.A2.A13.A17.2A100.2A11.A2.A13.A17.2A
100.2A11.A2.A13.A17.2A$51.A2.A11.2A14.3A116.A2.A11.2A14.3A116.A2.A11.
2A14.3A$46.2A4.A.A147.A.A147.A.A$46.2A5.A149.A149.A2$82.3A147.3A147.3A
$44.2A5.2A20.2A7.A111.2A5.2A20.2A7.A111.2A5.2A20.2A7.A$44.A2.A.A2.A20.
2A7.A.A109.A2.A.A2.A20.2A7.A.A109.A2.A.A2.A20.2A7.A.A$45.3A.3A31.2A110.
3A.3A31.2A110.3A.3A31.2A$48.A149.A149.A$45.2A2.A145.2A2.A145.2A2.A$44.
A2.2A145.A2.2A145.A2.2A$44.2A148.2A148.2A3$69.3A147.3A147.3A$69.A149.
A149.A$70.A149.A149.A13$85.2A148.2A148.2A$84.2A148.2A148.2A$86.A149.A
149.A!

[russellsprouts]

I do not know if something reasonable for our purposes work ... build a rather cheap pattern which would explode by some phase modulated glider signal ... which does not appear else in the DNA (and goes cleanly through the DNA loop)? ...

Hmm that seems possible but would difficult. We could place an oscillator just off the glider lane so that gliders in some phases pass through it, but others can interact. Then we have to create recipe sections that are careful with the phases to avoid breaking it.

If we need to build another path from otts to "destroy the eater" which would be triggered by central clock of neighbour building the cell ... it could become expensive ... (especially the synchronization). Disadvantage is the on-off switcher should be “permanent” … is direction switching of apg´s unidimensional ship ecca1 fast enough?

My thought was to have the cell unblock itself from its clock output. Instead of OTTs, the clock output would be pointed to unblock the lane whenever we need it to.

Some possibilities:

• The clock could tick 64x per glider loop, so we can unblock a construction arm at 64 spots for timing (or more or less if we want)
• We could have a separate clock in each corner with different programming
• We could have a single central clock which has separate programming for each direction.
• We could have the central clock be symmetric and send gliders in all directions each time we have programmed (based on the 4 barreled p256 gun), and use a quadrisnark in the middle of each edge. We would use OTTs to re-phase each quadrisnark, so that each construction arm gets a different sequence of timing gliders.

[Hippo.69]

I do not know if something reasonable for our purposes work ... build a rather cheap pattern which would explode by some phase modulated glider signal ... which does not appear else in the DNA (and goes cleanly through the DNA loop)? ...

Hmm that seems possible but would difficult. We could place an oscillator just off the glider lane so that gliders in some phases pass through it, but others can interact. Then we have to create recipe sections that are careful with the phases to avoid breaking it.

If we need to build another path from otts to "destroy the eater" which would be triggered by central clock of neighbour building the cell ... it could become expensive ... (especially the synchronization). Disadvantage is the on-off switcher should be “permanent” … is direction switching of apg´s unidimensional ship ecca1 fast enough?

My thought was to have the cell unblock itself from its clock output. Instead of OTTs, the clock output would be pointed to unblock the lane whenever we need it to.

Some possibilities:

• The clock could tick 64x per glider loop, so we can unblock a construction arm at 64 spots for timing (or more or less if we want)
• We could have a separate clock in each corner with different programming
• We could have a single central clock which has separate programming for each direction.
• We could have the central clock be symmetric and send gliders in all directions each time we have programmed (based on the 4 barreled p256 gun), and use a quadrisnark in the middle of each edge. We would use OTTs to re-phase each quadrisnark, so that each construction arm gets a different sequence of timing gliders.

4 outputs at $2^8$ would be too expensive to scale 4 times to $2^{24}$ or so. Having $2^{18}$ clock and divide it's signal is cheaper ... building several high period clocks is expensive as well ...

[speedydelete]

I am not sure how much would we gain by sc61/sc70, but we definitely need more then one splitter.
And we would definitely need transparent lane insertor (to fill the prepeared DNA loop).
Current design requires shell with 4 insertors on all of its 4 sides.
We need a splitter to get the compute the next state part of DNA, we need 3 splitters to send state to neighbors.
(Currently we use temporary splitter in the cell allocation ... sending 2 crabs 2 stretchers in parallel ...)

I am not sure how much "neo spartan" your nontransparent splitter is, probably bespoke extensions to pslmake would be required to find a slow salvo for it. We would also lose a lot of hash friendliness using longer periods in the circuitry (excluding powers of two).

So we have to consider the gains from the faster circuits compared to loses caused by increased costs of the new replacement circuitry.

I think is still worth it... though maybe the p46 version is better. 256 - 90 = 166, and 90 - 61 = 29, so there are 29 more timing gaps, for 5g recipes there are already 2x the possibilites, and this is assuming all collisions get up to timing gap 256, which most of them don't, heuristically it appears to be about that each one uses 70 timing gaps (for the 2g recipes starting with elbow xs4_33/9, xs4_33/9 is the normal pi elbow, the number after the slash is the lane number).

Anivec has posted new transparent lane inserters. How many speed tunnels do we need? It should be only 2? We can push the Herschel along a longer track to emit more gliders from 1 splitter.

Also, the program is much much faster for sc61/sc70 than sc90 because all the timing gaps are smaller. We already have a plan for synthesizing that big catalyst (posted by TigerCub414 on Discord):

Code: Select all

x = 24, y = 13, rule = B3/S23
9bobo$10b2o$10bo3$22b2o$22b2o$2o3b2o$obobobo7b2o$2bobo9b2o$2bobo$obob
obo$2o3b2o!

I am bad at understanding complicated logic circuitry... sorry. I will try to understand though!

[Hippo.69]

Code: Select all

x = 24, y = 13, rule = B3/S23
9bobo$10b2o$10bo3$22b2o$22b2o$2o3b2o$obobobo7b2o$2bobo9b2o$2bobo$obob
obo$2o3b2o!

This is helpfull, there would be no problem to incorporate bespoke for it to pslmake.

We would need a lot of the G->H. The circuitry we are building have size say about $2^{21}-2^{26}$ having hershel tracks sizes above $2^8$ is impractical. This is why the pattern consists of rather isolated islands.

I do not want to sound rude, but I would prefere to finish the current proposed solution then rebuilding the construction from scratch. Of couse if someone else decides to do and debug the changes, I would be happy it is working ... .

I would prefere path which we have chosen in unidimensional ship ... do not throw away what looks reasonable debuged even when slightly inefficient, rather finish it as efficiently as current technology offers and then rebuild parts in order of their inefficiency ...

Rebuilds always generate complications ... having completed pattern simplifies the rebuilds.

So far sc90 is the mostly used standard, this is why snarkmaker uses it. Changing to other speeds would create additional requests for it, which would be of less general use ... (I would prefere to use in envelope technology for other construction rather to spent the resources for speeding snarkmaker up).

[speedydelete]

I do not want to sound rude, but I would prefere to finish the current proposed solution then rebuilding the construction from scratch. Of couse if someone else decides to do and debug the changes, I would be happy it is working ... .

Ok, sure. The only thing that will need to be changed in a 0E0P built with the new techniques is the recipe. Yeah, it's probably a good idea to build the new metacell using the old single-channel, then migrate it to the new one separately...