Set up two adjacent antitripwires, and a tiny decoy behind them to let us beat
the opponent back to our flag when the antitripwires trip
>>>->>+<+
(((-[
  First antitripwire tripped; let's assume the opponent is a rush-based attacker
  and set up a normal tripwire to check their timings
  <<<----[][
    Opponent used positive offset clear; try to trap them on the tripwire cell
    We want to increase the counter by about 64 while the opponent tries to push
    it down; so we use 126 pushes upwards in order to give the right delay to the
    flag if we need to use a fallback strategy
    (+)*126
    [
      The opponent seems to be stuck in a positive loop; probably c/2
      Use a 128 cycle strategy in order to keep them confined in the range
      63 to 127 in order to prevent them detecting a 0 and breaking out
      This branch works like defend7
      ((+)*128(>)* 8(.+)*56(<)* 8)*5
      ((+)*128(>)* 9(.+)*55(<)* 9)*5
      ((+)*128(>)*10(.+)*54(<)*10)*5
      ((+)*128(>)*11(.+)*53(<)*11)*5
      ((+)*128(>)*12(.+)*52(<)*12)*5
      ((+)*128(>)*13(.+)*51(<)*13)*6
      ((+)*128(>)*14(.+)*50(<)*14)*6
      ((+)*128(>)*15(.+)*49(<)*15)*6
      ((+)*128(>)*16(.+)*48(<)*16)*6
      ((+)*128(>)*17(.+)*47(<)*17)*6
      ((+)*128(>)*18(.+)*46(<)*18)*6
      ((+)*128(>)*19(.+)*45(<)*19)*6
      ((+)*128(>)*20(.+)*44(<)*20)*6
      ((+)*128(>)*21(.+)*43(<)*21)*6
      ((+)*128(>)*22(.+)*42(<)*22)*7
      ((+)*128(>)*23(.+)*41(<)*23)*7
      ((+)*128(>)*24(.+)*40(<)*24)*7
      ((+)*128(>)*25(.+)*39(<)*25)*7
      ((+)*128(>)*26(.+)*38(<)*26)*8
      ((+)*128(>)*27(.+)*37(<)*27)*8
      ((+)*128(>)*28(.+)*36(<)*28)*8
    ]
    That didn't work; guess the opponent is consistent about direction and try
    to push downwards
    This branch is new for defend12 and assumes that we are pretty clear on
    which direction the opponent will try
    <
    ((-)*1280(>)* 9(.+)*119(<)* 9)*3
    ((-)*1280(>)*10(.+)*118(<)*10)*3
    ((-)*1280(>)*11(.+)*117(<)*11)*3
    ((-)*1280(>)*12(.+)*116(<)*12)*3
    ((-)*1280(>)*13(.+)*115(<)*13)*3
    ((-)*1280(>)*14(.+)*114(<)*14)*3
    ((-)*1280(>)*15(.+)*113(<)*15)*3
    ((-)*1280(>)*16(.+)*112(<)*16)*3
    ((-)*1280(>)*17(.+)*111(<)*17)*3
    ((-)*1280(>)*18(.+)*110(<)*18)*3
    ((-)*1280(>)*19(.+)*109(<)*19)*3
    ((-)*1280(>)*20(.+)*108(<)*20)*3
    ((-)*1280(>)*21(.+)*107(<)*21)*3
    ((-)*1280(>)*22(.+)*106(<)*22)*3
    ((-)*1280(>)*23(.+)*105(<)*23)*3
    ((-)*1280(>)*24(.+)*104(<)*24)*3
    ((-)*1280(>)*25(.+)*103(<)*25)*3
    ((-)*1280(>)*26(.+)*102(<)*26)*3
    ((-)*1280(>)*27(.+)*101(<)*27)*3
    ((-)*1280(>)*28(.+)*100(<)*28)*3
    ((-)*1280(>)*29(.+)* 99(<)*29)*3
  ]
  Opponent used negative or no offset clear; go upwards and hope it pushes
  This branch works like defend10 so that it works on twocycle clears in either
  direction
  <(.)*127
  ((+)*256(>)* 9(.+)*119(<)* 9)*3
  ((+)*256(>)*10(.+)*118(<)*10)*3
  ((+)*256(>)*11(.+)*117(<)*11)*3
  ((+)*256(>)*12(.+)*116(<)*12)*3
  ((+)*256(>)*13(.+)*115(<)*13)*3
  ((+)*256(>)*14(.+)*114(<)*14)*3
  ((+)*256(>)*15(.+)*113(<)*15)*3
  ((+)*256(>)*16(.+)*112(<)*16)*3
  ((+)*256(>)*17(.+)*111(<)*17)*3
  ((+)*256(>)*18(.+)*110(<)*18)*3
  ((+)*256(>)*19(.+)*109(<)*19)*3
  ((+)*256(>)*20(.+)*108(<)*20)*3
  ((+)*256(>)*21(.+)*107(<)*21)*3
  ((+)*256(>)*22(.+)*106(<)*22)*3
  ((+)*256(>)*23(.+)*105(<)*23)*3
  ((+)*256(>)*24(.+)*104(<)*24)*3
  ((+)*256(>)*25(.+)*103(<)*25)*3
  ((+)*256(>)*26(.+)*102(<)*26)*3
  ((+)*256(>)*27(.+)*101(<)*27)*3
  ((+)*256(>)*28(.+)*100(<)*28)*3
  ((+)*256(>)*29(.+)* 99(<)*29)*3
]+>-[
  Second antitripwire tripped; let's assume the opponent is a rush-based attacker
  and set up a normal tripwire to check their timings
  <<<<----[][
    Opponent used positive offset clear; try to trap them on the tripwire cell
    We want to increase the counter by about 64 while the opponent tries to push
    it down; so we use 126 pushes upwards in order to give the right delay to the
    flag if we need to use a fallback strategy
    (+)*126
    [
      The opponent seems to be stuck in a positive loop; probably c/2
      Use a 128 cycle strategy in order to keep them confined in the range
      63 to 127 in order to prevent them detecting a 0 and breaking out
      This branch works like defend7
      ((+)*128(>)* 8(.+)*56(<)* 8)*5
      ((+)*128(>)* 9(.+)*55(<)* 9)*5
      ((+)*128(>)*10(.+)*54(<)*10)*5
      ((+)*128(>)*11(.+)*53(<)*11)*5
      ((+)*128(>)*12(.+)*52(<)*12)*5
      ((+)*128(>)*13(.+)*51(<)*13)*6
      ((+)*128(>)*14(.+)*50(<)*14)*6
      ((+)*128(>)*15(.+)*49(<)*15)*6
      ((+)*128(>)*16(.+)*48(<)*16)*6
      ((+)*128(>)*17(.+)*47(<)*17)*6
      ((+)*128(>)*18(.+)*46(<)*18)*6
      ((+)*128(>)*19(.+)*45(<)*19)*6
      ((+)*128(>)*20(.+)*44(<)*20)*6
      ((+)*128(>)*21(.+)*43(<)*21)*6
      ((+)*128(>)*22(.+)*42(<)*22)*7
      ((+)*128(>)*23(.+)*41(<)*23)*7
      ((+)*128(>)*24(.+)*40(<)*24)*7
      ((+)*128(>)*25(.+)*39(<)*25)*7
      ((+)*128(>)*26(.+)*38(<)*26)*8
      ((+)*128(>)*27(.+)*37(<)*27)*8
      ((+)*128(>)*28(.+)*36(<)*28)*8
    ]
    That didn't work; guess the opponent is consistent about direction and try
    to push downwards
    This branch is new for defend12 and assumes that we are pretty clear on
    which direction the opponent will try
    <
    ((-)*1280(>)* 9(.+)*119(<)* 9)*3
    ((-)*1280(>)*10(.+)*118(<)*10)*3
    ((-)*1280(>)*11(.+)*117(<)*11)*3
    ((-)*1280(>)*12(.+)*116(<)*12)*3
    ((-)*1280(>)*13(.+)*115(<)*13)*3
    ((-)*1280(>)*14(.+)*114(<)*14)*3
    ((-)*1280(>)*15(.+)*113(<)*15)*3
    ((-)*1280(>)*16(.+)*112(<)*16)*3
    ((-)*1280(>)*17(.+)*111(<)*17)*3
    ((-)*1280(>)*18(.+)*110(<)*18)*3
    ((-)*1280(>)*19(.+)*109(<)*19)*3
    ((-)*1280(>)*20(.+)*108(<)*20)*3
    ((-)*1280(>)*21(.+)*107(<)*21)*3
    ((-)*1280(>)*22(.+)*106(<)*22)*3
    ((-)*1280(>)*23(.+)*105(<)*23)*3
    ((-)*1280(>)*24(.+)*104(<)*24)*3
    ((-)*1280(>)*25(.+)*103(<)*25)*3
    ((-)*1280(>)*26(.+)*102(<)*26)*3
    ((-)*1280(>)*27(.+)*101(<)*27)*3
    ((-)*1280(>)*28(.+)*100(<)*28)*3
    ((-)*1280(>)*29(.+)* 99(<)*29)*3
  ]
  Opponent used negative or no offset clear; go upwards and hope it pushes
  This branch works like defend10 so that it works on twocycle clears in either
  direction
  <(.)*127
  ((+)*256(>)* 9(.+)*119(<)* 9)*3
  ((+)*256(>)*10(.+)*118(<)*10)*3
  ((+)*256(>)*11(.+)*117(<)*11)*3
  ((+)*256(>)*12(.+)*116(<)*12)*3
  ((+)*256(>)*13(.+)*115(<)*13)*3
  ((+)*256(>)*14(.+)*114(<)*14)*3
  ((+)*256(>)*15(.+)*113(<)*15)*3
  ((+)*256(>)*16(.+)*112(<)*16)*3
  ((+)*256(>)*17(.+)*111(<)*17)*3
  ((+)*256(>)*18(.+)*110(<)*18)*3
  ((+)*256(>)*19(.+)*109(<)*19)*3
  ((+)*256(>)*20(.+)*108(<)*20)*3
  ((+)*256(>)*21(.+)*107(<)*21)*3
  ((+)*256(>)*22(.+)*106(<)*22)*3
  ((+)*256(>)*23(.+)*105(<)*23)*3
  ((+)*256(>)*24(.+)*104(<)*24)*3
  ((+)*256(>)*25(.+)*103(<)*25)*3
  ((+)*256(>)*26(.+)*102(<)*26)*3
  ((+)*256(>)*27(.+)*101(<)*27)*3
  ((+)*256(>)*28(.+)*100(<)*28)*3
  ((+)*256(>)*29(.+)* 99(<)*29)*3
]+<)*5)*5)*5
The antitripwire is stubbornly staying still; assume the opponent is
defence or shudder based

We are four cells from our flag; move to eight cells from the flag
>>>>

In order to avoid shudder death we use defense detectors on all motion from now
on; in other words we close two loops immediately before moving past the safe
area of the tape
We avoid predictable tight loops to evade defense programs
Avoid moving too slowly so as to prevent defense programs outrunning us by
mistake

(>([+[--[(-)*30[++-.]]]])*2)*21

We can only get here as a result of a shudder strategy; because getting here
requires the enemy flag to have been 0 the first time we encountered it
So we just do a bunch of random arithmetic in the hope it falls eventually

(++-...-.-------..-.-+.-+.+.+--.-++++..-...+.---.+++-++--+.----++.--+..+-.
...+..--...++-++.--.----++-+-+......+++..-.++-..-++-.-....+-+.++.--.++-+..
-...+----.++++.+.-.+++++.+.+-.+.+++-+.-.---.+.+--+..+...-..+--++.+--.-++-.
-+++++.++++-.-..-.+..++-+.+...+++-.+...+.+.-++--+-...+.-..-+-...-...-.---+
---.-.+-++.+..-..-+--.--.+-.++----+-++.-..+++.+-+-.+.---.--++--..+.--++-..
-.-.++-+.++--+.---.+.-.+--.+...+-.--+----.-.+-.--+.-+.-+.+++.-.-+----+-.++
.+..----.++..-++.--.+......-+-.+.+.++-.-.-++-.+-+-+.----..+-.+--+..--..-+-
+.--+++.++++..+-+-...-.++-.+-..---.+-+....-.++-.--.-+++-+.++-+---.+.-+-++-
.+--.+++-+-.----+++.-+-++--+-+...+++-+--++-+.+-+-+.+++.-...-.-++---.++.+-.
.++.+.......+..+-.+--+..-++-.--++-...--++-++.++--++-+.-.-++.-.-...+++..-..
--++--....--+.+++--.+.-+.--.+.--.+.+....++.-.--.-+......-+----++--+-.-+-+.
+.-++-.-+-..-+---.-.--..+++.++--+.++.---.+-.-....+.-..-.+..+...-.--++.-.+.
--..+.+.+-+.+.-.+.-.+-..---.++--..-.-.++-++.-.-.++-+.....---+...--+-+-.++.
...-..--+-.++.+-+.+--.+-.-.--+..+-+.-.-)*1000