space_elevator by quintopia, version 1_1
planned for future versions: more decoys if needed, backup attacks to handle timing attacks

>+>-(>)*6                 leave two tripwires and go find the other guy
+>                        i'll just leave this here
[(<)*8(+)*32             opponent found; back off fast and build a big decoy
	(>)*8([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*10
]>                        look again! 2
[(<)*9(+)*32             opponent found; back off fast and build a big decoy
	(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*9[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                        look again! 3
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
<
 +[                       tripwire tripped! the opponent is working on our flag! 111 cycles into program; opponent cannot have reduced flag by more than 47; wait 98 and start 2-cycle defend
    <<(.)*99              board is 12 wide
	((+)*256 (>)*11 (+.)*117 (<)*11)*2
	(+)*256 (>)*11 (+.)*22 > (+.)*94 (<)*12
	(+)*256 (>)*12 (+.)*116 (<)*12
	(+)*256 (>)*12 (+.)*46 > (+.)*69 (<)*13
	(+)*256 (>)*13 (+.)*115 (<)*13
	(+)*256 (>)*13 (+.)*72 > (+.)*42 (<)*14
	(+)*256 (>)*14 (+.)*114 (<)*14
	(+)*256 (>)*14 (+.)*100 > (+.)*13 (<)*15
	((+)*256 (>)*15 (+.)*113 (<)*15)*2
	(+)*256 (>)*15 (+.)*17 > (+.)*95 (<)*16
	(+)*256 (>)*16 (+.)*112 (<)*16
	(+)*256 (>)*16 (+.)*49 > (+.)*62 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*83 > (+.)*27 (<)*18
	((+)*256 (>)*18 (+.)*110 (<)*18)*2
	(+)*256 (>)*18 (+.)*9 > (+.)*100 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*47 > (+.)*61 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*87 > (+.)*20 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*22 > (+.)*84 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*66 > (+.)*39 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*7 > (+.)*97 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*55 > (+.)*48 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*2 > (+.)*100 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*54 > (+.)*47 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*7 > (+.)*93 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*63 > (+.)*36 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*22
  ]-
 <-[                      tripwire tripped! the opponent is working on our flag! 111 cycles into program; opponent cannot have reduced flag by more than 47; wait 98 and start 2-cycle defend
    <(.)*99              board is 12 wide
	((+)*256 (>)*11 (+.)*117 (<)*11)*2
	(+)*256 (>)*11 (+.)*22 > (+.)*94 (<)*12
	(+)*256 (>)*12 (+.)*116 (<)*12
	(+)*256 (>)*12 (+.)*46 > (+.)*69 (<)*13
	(+)*256 (>)*13 (+.)*115 (<)*13
	(+)*256 (>)*13 (+.)*72 > (+.)*42 (<)*14
	(+)*256 (>)*14 (+.)*114 (<)*14
	(+)*256 (>)*14 (+.)*100 > (+.)*13 (<)*15
	((+)*256 (>)*15 (+.)*113 (<)*15)*2
	(+)*256 (>)*15 (+.)*17 > (+.)*95 (<)*16
	(+)*256 (>)*16 (+.)*112 (<)*16
	(+)*256 (>)*16 (+.)*49 > (+.)*62 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*83 > (+.)*27 (<)*18
	((+)*256 (>)*18 (+.)*110 (<)*18)*2
	(+)*256 (>)*18 (+.)*9 > (+.)*100 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*47 > (+.)*61 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*87 > (+.)*20 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*22 > (+.)*84 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*66 > (+.)*39 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*7 > (+.)*97 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*55 > (+.)*48 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*2 > (+.)*100 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*54 > (+.)*47 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*7 > (+.)*93 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*63 > (+.)*36 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*22
   ]+

>(-)*32                 tripwire not tripped! assume opponent is defender or slow rush
<(+)*32
	(>)*9(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*9
]+>                       look again! 4
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
<<
 +[
                          tripewire tripped!
     <<(.)*97             board is 13 wide
	((+)*256 (>)*12 (+.)*116 (<)*12)*2
	(+)*256 (>)*12 (+.)*24 > (+.)*91 (<)*13
	(+)*256 (>)*13 (+.)*115 (<)*13
	(+)*256 (>)*13 (+.)*50 > (+.)*64 (<)*14
	(+)*256 (>)*14 (+.)*114 (<)*14
	(+)*256 (>)*14 (+.)*78 > (+.)*35 (<)*15
	(+)*256 (>)*15 (+.)*113 (<)*15
	(+)*256 (>)*15 (+.)*108 > (+.)*4 (<)*16
	((+)*256 (>)*16 (+.)*112 (<)*16)*2
	(+)*256 (>)*16 (+.)*28 > (+.)*83 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*62 > (+.)*48 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*98 > (+.)*11 (<)*19
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*27 > (+.)*81 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*67 > (+.)*40 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*2 > (+.)*104 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*46 > (+.)*59 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*92 > (+.)*12 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*36 > (+.)*67 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*86 > (+.)*16 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*36 > (+.)*65 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*90 > (+.)*10 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*46 > (+.)*53 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*5
  ]-
 <-[
                          tripewire tripped!
     <(.)*97              board is 13 wide
	((+)*256 (>)*12 (+.)*116 (<)*12)*2
	(+)*256 (>)*12 (+.)*24 > (+.)*91 (<)*13
	(+)*256 (>)*13 (+.)*115 (<)*13
	(+)*256 (>)*13 (+.)*50 > (+.)*64 (<)*14
	(+)*256 (>)*14 (+.)*114 (<)*14
	(+)*256 (>)*14 (+.)*78 > (+.)*35 (<)*15
	(+)*256 (>)*15 (+.)*113 (<)*15
	(+)*256 (>)*15 (+.)*108 > (+.)*4 (<)*16
	((+)*256 (>)*16 (+.)*112 (<)*16)*2
	(+)*256 (>)*16 (+.)*28 > (+.)*83 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*62 > (+.)*48 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*98 > (+.)*11 (<)*19
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*27 > (+.)*81 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*67 > (+.)*40 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*2 > (+.)*104 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*46 > (+.)*59 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*92 > (+.)*12 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*36 > (+.)*67 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*86 > (+.)*16 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*36 > (+.)*65 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*90 > (+.)*10 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*46 > (+.)*53 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*5
  ]-

  >>(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
   <(-)*32
   <(-)*32
	(>)*11([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*8[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]

]>                        look again! 5
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
<<<
 +[
                          tripwire tripped!
    <<(.)*96               board is 14 wide
	((+)*256 (>)*13 (+.)*115 (<)*13)*2
	(+)*256 (>)*13 (+.)*26 > (+.)*88 (<)*14
	(+)*256 (>)*14 (+.)*114 (<)*14
	(+)*256 (>)*14 (+.)*54 > (+.)*59 (<)*15
	(+)*256 (>)*15 (+.)*113 (<)*15
	(+)*256 (>)*15 (+.)*84 > (+.)*28 (<)*16
	((+)*256 (>)*16 (+.)*112 (<)*16)*2
	(+)*256 (>)*16 (+.)*4 > (+.)*107 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*38 > (+.)*72 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*74 > (+.)*35 (<)*19
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*3 > (+.)*105 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*43 > (+.)*64 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*85 > (+.)*21 (<)*22
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*23 > (+.)*82 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*69 > (+.)*35 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*13 > (+.)*90 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*63 > (+.)*39 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*13 > (+.)*88 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*67 > (+.)*33 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*23 > (+.)*76 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*81
 ]-
<-[
                          tripwire tripped!
    <(.)*96               board is 14 wide
	((+)*256 (>)*13 (+.)*115 (<)*13)*2
	(+)*256 (>)*13 (+.)*26 > (+.)*88 (<)*14
	(+)*256 (>)*14 (+.)*114 (<)*14
	(+)*256 (>)*14 (+.)*54 > (+.)*59 (<)*15
	(+)*256 (>)*15 (+.)*113 (<)*15
	(+)*256 (>)*15 (+.)*84 > (+.)*28 (<)*16
	((+)*256 (>)*16 (+.)*112 (<)*16)*2
	(+)*256 (>)*16 (+.)*4 > (+.)*107 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*38 > (+.)*72 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*74 > (+.)*35 (<)*19
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*3 > (+.)*105 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*43 > (+.)*64 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*85 > (+.)*21 (<)*22
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*23 > (+.)*82 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*69 > (+.)*35 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*13 > (+.)*90 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*63 > (+.)*39 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*13 > (+.)*88 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*67 > (+.)*33 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*23 > (+.)*76 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*81
 ]+
  >>>(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
    <(-)*33
    <(-)*32
    <(+)*32
	(>)*11(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*8
]>                        look again! 6
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
<<<<
 +[
                          tripwire tripped!
    <<(.)*94               board is 15 wide
	((+)*256 (>)*14 (+.)*114 (<)*14)*2
	(+)*256 (>)*14 (+.)*28 > (+.)*85 (<)*15
	(+)*256 (>)*15 (+.)*113 (<)*15
	(+)*256 (>)*15 (+.)*58 > (+.)*54 (<)*16
	(+)*256 (>)*16 (+.)*112 (<)*16
	(+)*256 (>)*16 (+.)*90 > (+.)*21 (<)*17
	((+)*256 (>)*17 (+.)*111 (<)*17)*2
	(+)*256 (>)*17 (+.)*13 > (+.)*97 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*49 > (+.)*60 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*87 > (+.)*21 (<)*20
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*19 > (+.)*88 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*61 > (+.)*45 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*105 > (+.)*0 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*46 > (+.)*58 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*94 > (+.)*9 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*41 > (+.)*61 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*93 > (+.)*8 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*46 > (+.)*54 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*2 > (+.)*97 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*60
 ]+
<-[
                          tripwire tripped!
    <(.)*94               board is 15 wide
	((+)*256 (>)*14 (+.)*114 (<)*14)*2
	(+)*256 (>)*14 (+.)*28 > (+.)*85 (<)*15
	(+)*256 (>)*15 (+.)*113 (<)*15
	(+)*256 (>)*15 (+.)*58 > (+.)*54 (<)*16
	(+)*256 (>)*16 (+.)*112 (<)*16
	(+)*256 (>)*16 (+.)*90 > (+.)*21 (<)*17
	((+)*256 (>)*17 (+.)*111 (<)*17)*2
	(+)*256 (>)*17 (+.)*13 > (+.)*97 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*49 > (+.)*60 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*87 > (+.)*21 (<)*20
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*19 > (+.)*88 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*61 > (+.)*45 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*105 > (+.)*0 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*46 > (+.)*58 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*94 > (+.)*9 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*41 > (+.)*61 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*93 > (+.)*8 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*46 > (+.)*54 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*2 > (+.)*97 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*60
 ]-
  >>>>(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
     <(-)*33
     <(-)*33
     <(+)*32
     <(-)*32
	(>)*13([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*7[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                       look again! 7
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*5
 +[
                          you get the idea
     <<(.)*93
	((+)*256 (>)*15 (+.)*113 (<)*15)*2
	(+)*256 (>)*15 (+.)*30 > (+.)*82 (<)*16
	(+)*256 (>)*16 (+.)*112 (<)*16
	(+)*256 (>)*16 (+.)*62 > (+.)*49 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*96 > (+.)*14 (<)*18
	((+)*256 (>)*18 (+.)*110 (<)*18)*2
	(+)*256 (>)*18 (+.)*22 > (+.)*87 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*60 > (+.)*48 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*100 > (+.)*7 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*35 > (+.)*71 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*79 > (+.)*26 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*20 > (+.)*84 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*68 > (+.)*35 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*15 > (+.)*87 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*67 > (+.)*34 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*20 > (+.)*80 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*76 > (+.)*23 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*35
 ]-
<-[
     <(.)*93
	((+)*256 (>)*15 (+.)*113 (<)*15)*2
	(+)*256 (>)*15 (+.)*30 > (+.)*82 (<)*16
	(+)*256 (>)*16 (+.)*112 (<)*16
	(+)*256 (>)*16 (+.)*62 > (+.)*49 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*96 > (+.)*14 (<)*18
	((+)*256 (>)*18 (+.)*110 (<)*18)*2
	(+)*256 (>)*18 (+.)*22 > (+.)*87 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*60 > (+.)*48 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*100 > (+.)*7 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*35 > (+.)*71 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*79 > (+.)*26 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*20 > (+.)*84 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*68 > (+.)*35 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*15 > (+.)*87 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*67 > (+.)*34 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*20 > (+.)*80 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*76 > (+.)*23 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*35
]+
  >>>>>(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*32
      <(+)*32
	(>)*13(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*7
]+>                        look again! 8
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*6
 +[
     <<(.)*91
	((+)*256 (>)*16 (+.)*112 (<)*16)*2
	(+)*256 (>)*16 (+.)*32 > (+.)*79 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*66 > (+.)*44 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*102 > (+.)*7 (<)*19
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*31 > (+.)*77 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*71 > (+.)*36 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*6 > (+.)*100 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*50 > (+.)*55 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*96 > (+.)*8 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*40 > (+.)*63 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*90 > (+.)*12 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*40 > (+.)*61 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*94 > (+.)*6 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*50 > (+.)*49 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*9

 ]+
<-[
     <(.)*91
	((+)*256 (>)*16 (+.)*112 (<)*16)*2
	(+)*256 (>)*16 (+.)*32 > (+.)*79 (<)*17
	(+)*256 (>)*17 (+.)*111 (<)*17
	(+)*256 (>)*17 (+.)*66 > (+.)*44 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*102 > (+.)*7 (<)*19
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*31 > (+.)*77 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*71 > (+.)*36 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*6 > (+.)*100 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*50 > (+.)*55 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*96 > (+.)*8 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*40 > (+.)*63 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*90 > (+.)*12 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*40 > (+.)*61 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*94 > (+.)*6 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*50 > (+.)*49 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*9
 ]-
  (>)*6(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*32
      <(-)*32
	(>)*15([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*6[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                        look again! 9
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*7
 +[
     <<(.)*90
	((+)*256 (>)*17 (+.)*111 (<)*17)*2
	(+)*256 (>)*17 (+.)*34 > (+.)*76 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*70 > (+.)*39 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*108 > (+.)*0 (<)*20
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*40 > (+.)*67 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*82 > (+.)*24 (<)*22
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*20 > (+.)*85 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*66 > (+.)*38 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*10 > (+.)*93 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*60 > (+.)*42 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*10 > (+.)*91 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*64 > (+.)*36 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*20 > (+.)*79 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*78

 ]+
<-[
     <(.)*90
	((+)*256 (>)*17 (+.)*111 (<)*17)*2
	(+)*256 (>)*17 (+.)*34 > (+.)*76 (<)*18
	(+)*256 (>)*18 (+.)*110 (<)*18
	(+)*256 (>)*18 (+.)*70 > (+.)*39 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*108 > (+.)*0 (<)*20
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*40 > (+.)*67 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*82 > (+.)*24 (<)*22
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*20 > (+.)*85 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*66 > (+.)*38 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*10 > (+.)*93 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*60 > (+.)*42 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*10 > (+.)*91 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*64 > (+.)*36 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*20 > (+.)*79 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*78
  ]-

  (>)*7(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*32
      <(-)*32
	(>)*15(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*6
]>                       look again! 10
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*8
 +[
    <<(.)*88
	((+)*256 (>)*18 (+.)*110 (<)*18)*2
	(+)*256 (>)*18 (+.)*36 > (+.)*73 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*74 > (+.)*34 (<)*20
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*6 > (+.)*101 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*48 > (+.)*58 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*92 > (+.)*13 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*33 > (+.)*71 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*81 > (+.)*22 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*28 > (+.)*74 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*80 > (+.)*21 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*33 > (+.)*67 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*89 > (+.)*10 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*48
   ]-
 <-[
    <(.)*88
	((+)*256 (>)*18 (+.)*110 (<)*18)*2
	(+)*256 (>)*18 (+.)*36 > (+.)*73 (<)*19
	(+)*256 (>)*19 (+.)*109 (<)*19
	(+)*256 (>)*19 (+.)*74 > (+.)*34 (<)*20
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*6 > (+.)*101 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*48 > (+.)*58 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*92 > (+.)*13 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*33 > (+.)*71 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*81 > (+.)*22 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*28 > (+.)*74 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*80 > (+.)*21 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*33 > (+.)*67 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*89 > (+.)*10 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*48
   ]+

  (>)*8(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*32
      <(+)*32
	(>)*17([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*5[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                        look again! 11
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*9
 +[
    <<(.)*87
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*38 > (+.)*70 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*78 > (+.)*29 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*13 > (+.)*93 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*57 > (+.)*48 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*103 > (+.)*1 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*47 > (+.)*56 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*97 > (+.)*5 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*47 > (+.)*54 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*0 > (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*56 > (+.)*43 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*15

  ]-
<-[  
    <(.)*87
	((+)*256 (>)*19 (+.)*109 (<)*19)*2
	(+)*256 (>)*19 (+.)*38 > (+.)*70 (<)*20
	(+)*256 (>)*20 (+.)*108 (<)*20
	(+)*256 (>)*20 (+.)*78 > (+.)*29 (<)*21
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*13 > (+.)*93 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*57 > (+.)*48 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*103 > (+.)*1 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*47 > (+.)*56 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*97 > (+.)*5 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*47 > (+.)*54 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*0 > (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*56 > (+.)*43 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*15
  ]+
  (>)*9(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*32
	(>)*16(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*5
]+>                        look again! 12
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*10
 +[
    <<(.)*85
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*40 > (+.)*67 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*82 > (+.)*24 (<)*22
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*20 > (+.)*85 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*66 > (+.)*38 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*10 > (+.)*93 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*60 > (+.)*42 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*10 > (+.)*91 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*64 > (+.)*36 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*20 > (+.)*79 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*78
  ]-
<-[
    <(.)*85
	((+)*256 (>)*20 (+.)*108 (<)*20)*2
	(+)*256 (>)*20 (+.)*40 > (+.)*67 (<)*21
	(+)*256 (>)*21 (+.)*107 (<)*21
	(+)*256 (>)*21 (+.)*82 > (+.)*24 (<)*22
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*20 > (+.)*85 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*66 > (+.)*38 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*10 > (+.)*93 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*60 > (+.)*42 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*10 > (+.)*91 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*64 > (+.)*36 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*20 > (+.)*79 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*78
  ]+
 (>)*10(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*17([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*4[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                       look again! 13
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*11
 +[
    <<(.)*84
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*42 > (+.)*64 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*86 > (+.)*19 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*27 > (+.)*77 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*75 > (+.)*28 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*22 > (+.)*80 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*74 > (+.)*27 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*27 > (+.)*73 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*83 > (+.)*16 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*42
  ]-
<-[
    <(.)*84
	((+)*256 (>)*21 (+.)*107 (<)*21)*2
	(+)*256 (>)*21 (+.)*42 > (+.)*64 (<)*22
	(+)*256 (>)*22 (+.)*106 (<)*22
	(+)*256 (>)*22 (+.)*86 > (+.)*19 (<)*23
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*27 > (+.)*77 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*75 > (+.)*28 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*22 > (+.)*80 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*74 > (+.)*27 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*27 > (+.)*73 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*83 > (+.)*16 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*42
  ]+
 (>)*11(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*16(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*4
]>                        look again! 14
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*12
 +[
    <<(.)*82
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*44 > (+.)*61 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*90 > (+.)*14 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*34 > (+.)*69 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*84 > (+.)*18 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*34 > (+.)*67 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*88 > (+.)*12 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*44 > (+.)*55 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*3
  ]-
<-[
    <(.)*82
	((+)*256 (>)*22 (+.)*106 (<)*22)*2
	(+)*256 (>)*22 (+.)*44 > (+.)*61 (<)*23
	(+)*256 (>)*23 (+.)*105 (<)*23
	(+)*256 (>)*23 (+.)*90 > (+.)*14 (<)*24
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*34 > (+.)*69 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*84 > (+.)*18 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*34 > (+.)*67 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*88 > (+.)*12 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*44 > (+.)*55 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*3
  ]+
 (>)*12(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*17([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*3[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                        look again! 15
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*13
 +[
    <<(.)*81
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*46 > (+.)*58 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*94 > (+.)*9 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*41 > (+.)*61 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*93 > (+.)*8 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*46 > (+.)*54 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*2 > (+.)*97 (<)*29	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*52 > (+.)*49 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*5 > (+.)*95 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*61 > (+.)*38 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*20
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*60
  ]-
<-[
    <(.)*81
	((+)*256 (>)*23 (+.)*105 (<)*23)*2
	(+)*256 (>)*23 (+.)*46 > (+.)*58 (<)*24
	(+)*256 (>)*24 (+.)*104 (<)*24
	(+)*256 (>)*24 (+.)*94 > (+.)*9 (<)*25
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*41 > (+.)*61 (<)*26
	(+)*256 (>)*26 (+.)*102 (<)*26
	(+)*256 (>)*26 (+.)*93 > (+.)*8 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*46 > (+.)*54 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*2 > (+.)*97 (<)*29	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*52 > (+.)*49 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*5 > (+.)*95 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*61 > (+.)*38 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*20
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*60
  ]+
 (>)*13(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*16(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*3
 
]+>                       look again! 16
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*14
 +[
    <<(.)*79
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*48 > (+.)*55 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*98 > (+.)*4 (<)*26	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*52 > (+.)*49 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*5 > (+.)*95 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*61 > (+.)*38 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*20
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*48 > (+.)*53 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*1 > (+.)*99 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*57 > (+.)*42 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*16
  ]-
<-[
    <(.)*79
	((+)*256 (>)*24 (+.)*104 (<)*24)*2
	(+)*256 (>)*24 (+.)*48 > (+.)*55 (<)*25
	(+)*256 (>)*25 (+.)*103 (<)*25
	(+)*256 (>)*25 (+.)*98 > (+.)*4 (<)*26	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*52 > (+.)*49 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*5 > (+.)*95 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*61 > (+.)*38 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*20
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*48 > (+.)*53 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*1 > (+.)*99 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*57 > (+.)*42 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*16
  ]+
 (>)*14(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*17([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*2[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                        look again! 17
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*15
 +[
    <<(.)*78
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*50 > (+.)*52 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*0 > (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*54 > (+.)*46 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*10 > (+.)*89 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*68
  ]-
<-[
    <(.)*78
	((+)*256 (>)*25 (+.)*103 (<)*25)*2
	(+)*256 (>)*25 (+.)*50 > (+.)*52 (<)*26
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*0 > (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*101 (<)*27
	(+)*256 (>)*27 (+.)*54 > (+.)*46 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*10 > (+.)*89 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*68
  ]+
 (>)*15(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*16(>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]])*2
 
]>                        look again! 18
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*16
 +[
    <<(.)*77
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*52 > (+.)*49 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*5 > (+.)*95 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*61 > (+.)*38 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*20
  ]-
<-[
    <(.)*77
	((+)*256 (>)*26 (+.)*102 (<)*26)*2
	(+)*256 (>)*26 (+.)*52 > (+.)*49 (<)*27
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*5 > (+.)*95 (<)*28
	(+)*256 (>)*28 (+.)*100 (<)*28
	(+)*256 (>)*28 (+.)*61 > (+.)*38 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*20
  ]+
 (>)*16(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*17[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
]>                       look again! 19
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*17
 +[
    <<(.)*75
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*54 > (+.)*46 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*10 > (+.)*89 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*68
  ]-
<-[
    <(.)*75
	((+)*256 (>)*27 (+.)*101 (<)*27)*2
	(+)*256 (>)*27 (+.)*54 > (+.)*46 (<)*28
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*10 > (+.)*89 (<)*29
	(+)*256 (>)*29 (+.)*99 (<)*29
	(+)*256 (>)*29 (+.)*68
 ]+
 (>)*17(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*17[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]
]>                        look again! 20
[(<)*8(-)*60              opponent found; back off fast and build a big decoy
(<)*18
 +[
    <<(.)*74
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*56 > (+.)*43 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*15
  ]-
<-[
    <(.)*74
	((+)*256 (>)*28 (+.)*100 (<)*28)*2
	(+)*256 (>)*28 (+.)*56 > (+.)*43 (<)*29
	((+)*256 (>)*29 (+.)*99 (<)*29)*2
	(+)*256 (>)*29 (+.)*15
  ]+
 (>)*18(+)*33                  tripwire not tripped! assume opponent is defender or slow rush
      <(-)*33
      <(-)*33
      <(+)*33
      <(-)*33
      <(+)*33
      <(+)*33
      <(-)*33
      <(+)*33
	(>)*17[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
 
]>                        look again! 21
[(-)*100[.-].[.++-------]              yeah, let's not jump through hoops when we're already at the flag :P
]