tangent = 9;
blue = 5;
red = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & field == val

done && state ^ done

state & 2 * OFFSET

count + num | error

FIELD == val < LENGTH

remember would refer back not seen

  blue =     ____    __    __

  tangent =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

sofa = 9;
table = 5;
chair = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < error | state

flag || offset << 0xff

rate * length || ERROR

flag | mask + length

count < options & error

remember would refer back not seen

  saddle =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

france = 5;
sweden = 4;
pencil = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < num + 2

done | error && done

2 < flag || error

0xff & bits < val

field == n & options

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  pencil =     ____    __    __

  germany =     ____    __    __

mars = 6;
jupiter = 8;
string = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << started & finished

started | 7 == temp

rate % flags & done

count % offset < n

finished && started || finished

remember would refer back not seen

  string =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

cow = 6;
pig = 9;
sheep = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + num << 0xff

state & flag | flags

finished || started ^ finished

val == 7 << error

n < resource && done

remember would refer back not seen

  sheep =     ____    __    __

  lizard =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

wasp = 8;
bee = 6;
fly = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG << TRUE * count

done << length + rate

options & length << options

error | state ^ mask

7 == rate + 2

remember would refer back not seen

  bee =     ____    __    __

  atom =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

blackbird = 5;
sparrow = 4;
exterior = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + offset && done

started << length | state

DONE || TRUE & finished

TRUE || rate + offset

NUM < n % num

remember would refer back not seen

  exterior =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

chapter = 5;
banana = 4;
apple = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & state + length

finished || TRUE | state

started << flag && started

bits & started || TRUE

field < count ^ TRUE

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

  chapter =     ____    __    __

hour = 5;
second = 6;
minute = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || started * 2

ERROR & error && finished

FINISHED && started + offset

num + rate ^ 0xff

2 + rate < 2

remember would refer back not seen

  tail =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

elm = 9;
comb = 6;
chestnut = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | options % length

count + rate * offset

started ^ resource == 7

state << 0xff == VAL

resource == temp || TRUE

remember would refer back not seen

  comb =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

january = 9;
june = 5;
october = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | state || finished

TRUE || error < VAL

TRUE && error | STARTED

N == rate % length

COUNT + started || finished

remember would refer back not seen

  june =     ____    __    __

  plastic =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

heart = 5;
lung = 9;
snake = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < val == resource

TRUE ^ finished | bits

rate * 2 + offset

field == resource && started

count + n == field

remember would refer back not seen

  snake =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

poker = 5;
solitaire = 6;
scrabble = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * rate | state

rate % error && done

FINISHED || finished == n

done || FLAG && TRUE

flag ^ mask & error

remember would refer back not seen

  poker =     ____    __    __

  occult =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

mandarin = 4;
dutch = 5;
fence = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field < STARTED << flag

n == field ^ started

bits ^ started && done

error && finished < 2

count / num ^ STARTED

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  fence =     ____    __    __

adjective = 5;
wax = 9;
verb = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & finished ^ flags

length % resource == VAL

done && offset << bits

flag && error % 2

options | flag << flags

remember would refer back not seen

  adjective =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

  wax =     ____    __    __

dress = 9;
shirt = 8;
trousers = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && flags & bits

options ^ field < length

bits ^ done || ERROR

bits ^ count + OFFSET

0xff | TRUE & options

remember would refer back not seen

  petrol =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

knife = 5;
occult = 9;
spoon = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options ^ done * rate

OPTIONS ^ options << done

bits << FLAG < 2

resource == mask | flags

MASK | field < num

remember would refer back not seen

  fork =     ____    __    __

  knife =     ____    __    __

  occult =     ____    __    __

  spoon =     ____    __    __

stream = 9;
grass = 5;
river = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * length << started

flag && TRUE == temp

options << 0xff ^ bits

length + count & bits

finished << state || flag

remember would refer back not seen

  stream =     ____    __    __

  grass =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

painter = 5;
plumber = 9;
builder = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & MASK && flag

state & 2 * num

0xff & done + count

started & OFFSET < 7

TRUE & flags << RATE

remember would refer back not seen

  painter =     ____    __    __

  plastic =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

saw = 8;
hammer = 4;
screwdriver = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & flags == n

TRUE & finished ^ flags

count + length * count

bits & mask | TRUE

rate + TEMP < n

remember would refer back not seen

  saw =     ____    __    __

  hammer =     ____    __    __

  atom =     ____    __    __

  screwdriver =     ____    __    __

green = 4;
blue = 8;
red = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & error || started

length + num << state

count * options & flags

NUM + n == resource

count + 2 ^ 0xff

remember would refer back not seen

  tangent =     ____    __    __

  red =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

chapter = 8;
sofa = 9;
chair = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + state | bits

num + count || TRUE

RESOURCE < 0xff << state

flags << 2 & finished

RESOURCE < offset == resource

remember would refer back not seen

  sofa =     ____    __    __

  chair =     ____    __    __

  chapter =     ____    __    __

  table =     ____    __    __

france = 4;
sweden = 8;
fence = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << error && started

temp < n ^ mask

2 << length * offset

2 < started | TRUE

2 < 7 || TRUE

remember would refer back not seen

  fence =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

mars = 5;
jupiter = 8;
venus = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == TRUE & error

field == error && done

started && flag & flags

state ^ n == field

resource == offset * 2

remember would refer back not seen

  wax =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

cow = 5;
membrane = 4;
sheep = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && TRUE * rate

MASK ^ STATE | ERROR

val == n + count

flag && started + 2

started ^ flag || done

remember would refer back not seen

  cow =     ____    __    __

  membrane =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

fly = 8;
bee = 6;
string = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == n < val

finished && 2 < rate

options | 0xff & mask

FINISHED && done << count

bits | state && finished

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  string =     ____    __    __

blackbird = 5;
sparrow = 4;
wheel = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && n == VAL

state | 2 * rate

flag && done ^ mask

STARTED | options + length

finished && options | mask

remember would refer back not seen

  blackbird =     ____    __    __

  wheel =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

pear = 8;
comb = 5;
apple = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || flag | mask

started | error < count

error && started || finished

flag | 0xff << flag

flag | finished == 7

remember would refer back not seen

  comb =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

second = 4;
minute = 9;
hour = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * length && finished

2 * count + rate

count * offset < field

count * rate << offset

2 * resource == n

remember would refer back not seen

  exterior =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

elm = 5;
chestnut = 9;
oak = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * num ^ done

2 * num | mask

length << done + rate

COUNT * flag || error

mask << num < 7

remember would refer back not seen

  oak =     ____    __    __

  chestnut =     ____    __    __

  engine =     ____    __    __

  elm =     ____    __    __

pencil = 4;
june = 5;
january = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + flag & TRUE

options << bits == val

num + TRUE && done

bits << started ^ options

count << done | STARTED

remember would refer back not seen

  june =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

  pencil =     ____    __    __

heart = 5;
liver = 9;
lung = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options << FINISHED || flag

resource < 0xff & state

n == 7 << RATE

length < temp && finished

val == flag ^ DONE

remember would refer back not seen

  heart =     ____    __    __

  report =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

poker = 9;
room = 8;
solitaire = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate < offset / num

resource == error | mask

N < offset + 2

field == temp || TRUE

mask ^ state & STARTED

remember would refer back not seen

  poker =     ____    __    __

  room =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

petrol = 5;
english = 9;
mandarin = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ TRUE && finished

finished ^ FINISHED * num

state | options ^ finished

options ^ mask + count

state | flag || started

remember would refer back not seen

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

  petrol =     ____    __    __

occult = 4;
noun = 5;
adjective = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ mask < NUM

FINISHED || started & mask

done ^ flag << MASK

error || started && flag

finished || 2 * num

remember would refer back not seen

  verb =     ____    __    __

  occult =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

trousers = 4;
shirt = 6;
grass = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || count + num

finished || done < n

flag || done << num

started || done == 7

DONE || bits ^ 0xff

remember would refer back not seen

  trousers =     ____    __    __

  dress =     ____    __    __

  grass =     ____    __    __

  shirt =     ____    __    __

fork = 6;
spoon = 9;
knife = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & flag && error

flag & num * count

BITS & options + rate

started & offset < 2

finished & done << 2

remember would refer back not seen

  spoon =     ____    __    __

  fork =     ____    __    __

  knife =     ____    __    __

  snake =     ____    __    __

river = 4;
stream = 9;
occult = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & field == val

started & options ^ finished

num + 2 % OFFSET

0xff & flags | started

LENGTH + n < count

remember would refer back not seen

  river =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  occult =     ____    __    __

painter = 8;
plastic = 6;
plumber = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS & flag || DONE

count + length << state

length * FINISHED & mask

2 + num == 7

num + 2 ^ options

remember would refer back not seen

  painter =     ____    __    __

  plastic =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

screwdriver = 6;
saw = 5;
atom = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + offset | options

length + num || done

n < field << count

finished << options & state

TEMP < 7 == field

remember would refer back not seen

  atom =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

blue = 8;
red = 6;
green = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < resource && started

RATE < field != RESOURCE

val == field + 2

temp == val * rate

2 + length * rate

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

  string =     ____    __    __

table = 9;
room = 4;
sofa = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < offset || flag

done || num + RATE

count * done & mask

state & started || STARTED

flag || TRUE * count

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  room =     ____    __    __

  sofa =     ____    __    __

germany = 4;
france = 8;
pencil = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ TRUE | flags

done << error & bits

0xff ^ count < offset

done | LENGTH * num

num + rate << flag

remember would refer back not seen

  germany =     ____    __    __

  pencil =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

chapter = 8;
mars = 5;
venus = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << field != val

temp == n < 2

0XFF & rate + count

started && DONE ^ bits

2 + VAL != temp

remember would refer back not seen

  venus =     ____    __    __

  chapter =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

sheep = 4;
pencil = 5;
cow = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * 2 ^ flag

length * rate != n

offset + mask | bits

options & bits != field

length << error || finished

remember would refer back not seen

  cow =     ____    __    __

  pencil =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

bee = 8;
wasp = 6;
fly = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < val ^ ERROR

length % finished && flag

length + rate || finished

TRUE && resource < offset

started && finished * rate

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  occult =     ____    __    __

  bee =     ____    __    __

blackbird = 6;
plastic = 9;
robin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + flag & done

options & bits | DONE

MASK & options << rate

2 + LENGTH < rate

temp < n + 2

remember would refer back not seen

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  plastic =     ____    __    __

tail = 5;
pear = 8;
banana = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ n != val

done | state || error

finished & error % 2

flag || done && TRUE

2 + flags ^ TRUE

remember would refer back not seen

  pear =     ____    __    __

  tail =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

hour = 8;
second = 5;
petrol = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < offset << mask

val == started && error

started || flag & started

2 * rate << options

0xff << error % count

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  petrol =     ____    __    __

oak = 6;
elm = 5;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & flags ^ started

STARTED ^ bits << count

flag << error ^ flags

bits ^ OPTIONS & state

finished && started << 2

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  occult =     ____    __    __

  chestnut =     ____    __    __

propeller = 4;
october = 5;
june = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < rate | started

7 == rate << length

state | flags + count

offset % finished || error

0xff | flags < NUM

remember would refer back not seen

  propeller =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

heart = 5;
lung = 8;
wax = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0XFF | error & mask

7 == val != 7

error || rate << flags

flag || started ^ bits

2 * COUNT + num

remember would refer back not seen

  wax =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

scrabble = 4;
solitaire = 8;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ flags * offset

error | started && done

val == finished || error

started | 0xff != 7

done && finished != resource

remember would refer back not seen

  solitaire =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

  grass =     ____    __    __

snake = 4;
english = 5;
dutch = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS & 7 < 2

flag || ERROR < 2

MASK | length << error

done | TRUE ^ mask

finished || 0xff | bits

remember would refer back not seen

  snake =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

verb = 6;
kettle = 5;
noun = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * error | finished

7 == val & TRUE

0xff & state && flag

temp == 7 ^ finished

finished && ERROR || TRUE

remember would refer back not seen

  adjective =     ____    __    __

  kettle =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

shirt = 9;
lizard = 8;
dress = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ done && flag

error ^ TRUE || started

state << 0xff + 2

started || error != 7

n < done & state

remember would refer back not seen

  lizard =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

spoon = 4;
fork = 6;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished << TRUE && error

TRUE << bits | done

TRUE && 2 + count

field == 7 | bits

mask << 2 < val

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  wood =     ____    __    __

stream = 8;
canal = 5;
exterior = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && error | started

length + done && error

done && TRUE & bits

error ^ flags + rate

n < rate * offset

remember would refer back not seen

  exterior =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

builder = 9;
painter = 5;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & temp != val

flags & started && flag

options & bits * rate

finished & count + 2

flags & options < n

remember would refer back not seen

  plastic =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

hammer = 4;
string = 6;
saw = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & 0xff << finished

finished & state ^ 0xff

length + offset && finished

flag & state | started

num + length * rate

remember would refer back not seen

  saw =     ____    __    __

  string =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

blue = 9;
red = 4;
comb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & finished || started

OFFSET + temp < val

length * TEMP != resource

count + length << 2

length + rate ^ started

remember would refer back not seen

  blue =     ____    __    __

  comb =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

wood = 5;
table = 4;
sofa = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + offset | flags

rate + 2 || error

field < num + length

flag << resource != n

2 < flag << started

remember would refer back not seen

  wood =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

  table =     ____    __    __

sweden = 4;
germany = 6;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started << flag & state

offset < mask ^ TRUE

num << FLAG && done

2 < n | FLAG

7 < resource || flag

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  kettle =     ____    __    __

  germany =     ____    __    __

venus = 8;
wheel = 5;
mars = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == 7 != resource

field == resource & TRUE

done && n != 7

flags ^ TRUE < field

temp == done && TRUE

remember would refer back not seen

  wheel =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

grass = 5;
pig = 8;
sheep = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && 0XFF & mask

done ^ state << TRUE

field == count * 2

started && 2 * count

done ^ TRUE | 0xff

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  grass =     ____    __    __

bee = 4;
fly = 9;
wax = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == offset + length

ERROR && started + num

finished ^ flag || started

error && finished < 7

mask | done != temp

remember would refer back not seen

  wax =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

report = 6;
blackbird = 8;
robin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && rate << 2

started | 0xff & state

error && flag ^ state

0XFF | started && finished

finished && TRUE | bits

remember would refer back not seen

  robin =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  report =     ____    __    __

tangent = 5;
apple = 6;
pear = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || TRUE ^ flags

bits | TRUE * num

FINISHED && error || finished

started || done | started

started | 2 + rate

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

  tangent =     ____    __    __

hour = 9;
second = 6;
engine = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | NUM < num

2 / length & flags

RATE * FLAG && TRUE

num * offset + OFFSET

OFFSET * temp < num

remember would refer back not seen

  second =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

  engine =     ____    __    __

chestnut = 9;
elm = 5;
saddle = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num / offset << finished

2 * length ^ 0xff

offset * 2 | 0xff

TRUE << options * count

num % offset || TRUE

remember would refer back not seen

  saddle =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

january = 8;
october = 5;
june = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << count + OFFSET

count + n != val

FINISHED << resource < field

offset + num & STARTED

0xff << TRUE ^ finished

remember would refer back not seen

  january =     ____    __    __

  october =     ____    __    __

  pencil =     ____    __    __

  june =     ____    __    __

liver = 6;
lung = 8;
petrol = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error << mask | options

finished << started || flag

rate < field != resource

temp == val < resource

rate < 0xff & started

remember would refer back not seen

  petrol =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

solitaire = 8;
room = 9;
scrabble = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == options << DONE

resource < error && started

val == flag ^ done

n < 2 * rate

n == 0xff | finished

remember would refer back not seen

  scrabble =     ____    __    __

  room =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

english = 8;
mandarin = 6;
dutch = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RESOURCE == flag || done

mask ^ flags != 7

0xff ^ flag & done

flags | STARTED << count

bits ^ started && flag

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  atom =     ____    __    __

  dutch =     ____    __    __

verb = 9;
occult = 6;
adjective = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | error ^ state

flags ^ bits * count

mask | finished || flag

finished ^ state + rate

TRUE || temp != field

remember would refer back not seen

  verb =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

  occult =     ____    __    __

dress = 9;
trousers = 5;
plastic = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || finished & flags

finished || TRUE && ERROR

error || FLAG * RATE

started || flag + count

error || offset < RESOURCE

remember would refer back not seen

  plastic =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

occult = 9;
spoon = 8;
knife = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & flags != TEMP

flag & error && TRUE

state & flags * offset

ERROR & options + OFFSET

flags & resource < temp

remember would refer back not seen

  occult =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

stream = 6;
river = 5;
exterior = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & flags << 2

mask & state ^ flags

offset + 2 && started

flag & 0xff | TRUE

offset + count * offset

remember would refer back not seen

  river =     ____    __    __

  exterior =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

plastic = 6;
builder = 5;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & TRUE || error

num + 7 < num

rate / field != VAL

LENGTH + count << TRUE

offset + started ^ FINISHED

remember would refer back not seen

  painter =     ____    __    __

  plumber =     ____    __    __

  plastic =     ____    __    __

  builder =     ____    __    __

hammer = 9;
string = 4;
screwdriver = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + rate | state

count + LENGTH || started

RATE < FIELD + rate

0xff << temp != n

OFFSET < LENGTH << num

remember would refer back not seen

  hammer =     ____    __    __

  saw =     ____    __    __

  string =     ____    __    __

  screwdriver =     ____    __    __

red = 5;
blue = 6;
pencil = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count % mask ^ flag

NUM * rate < count

ERROR && TRUE || error

error ^ 2 * rate

7 == RATE * NUM

remember would refer back not seen

  green =     ____    __    __

  red =     ____    __    __

  blue =     ____    __    __

  pencil =     ____    __    __

table = 6;
sofa = 8;
atom = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset / error || TRUE

TRUE | 7 < RATE

NUM + flag && TRUE

state & error && done

finished << 2 & state

remember would refer back not seen

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  atom =     ____    __    __

france = 4;
sweden = 6;
exterior = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < offset - rate

rate + 2 < count

num * 7 == val

COUNT * rate - offset

FLAG && done ^ state

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  exterior =     ____    __    __

jupiter = 4;
report = 5;
venus = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ done || error

7 == flag << 2

error << num * COUNT

started || finished < offset

rate << TRUE ^ started

remember would refer back not seen

  jupiter =     ____    __    __

  report =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

pig = 4;
cow = 5;
comb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == started ^ bits

count < n == temp

COUNT * num << options

done || TRUE ^ mask

options ^ mask & BITS

remember would refer back not seen

  comb =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

wax = 9;
wasp = 5;
fly = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || started << bits

2 << state - offset

field < rate ^ flags

flag || TRUE | done

count + num == 7

remember would refer back not seen

  wasp =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wax =     ____    __    __

robin = 6;
saddle = 4;
sparrow = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + TRUE & bits

done | started << options

length * started | 0xff

STARTED ^ started < FIELD

flag | done ^ error

remember would refer back not seen

  blackbird =     ____    __    __

  saddle =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

banana = 4;
chapter = 5;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag ^ started << mask

num < count << error

bits ^ val == n

num < done & mask

flag && 0XFF & flags

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  chapter =     ____    __    __

  apple =     ____    __    __

hour = 5;
plastic = 4;
minute = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && error * rate

started || resource == val

mask ^ rate - count

options & done - offset

done && finished == n

remember would refer back not seen

  plastic =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

  minute =     ____    __    __

grass = 4;
oak = 6;
chestnut = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + mask << STARTED

state | flag && finished

2 + num - OFFSET

length + finished ^ options

RATE << error | finished

remember would refer back not seen

  grass =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

june = 4;
october = 8;
january = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || count / NUM

length * offset & error

temp == 7 & flag

bits << finished || started

n == field - LENGTH

remember would refer back not seen

  june =     ____    __    __

  october =     ____    __    __

  membrane =     ____    __    __

  january =     ____    __    __

snake = 5;
heart = 6;
liver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & flag || started

LENGTH * 2 && error

started && flag | flags

TRUE & 0xff | done

bits | rate * length

remember would refer back not seen

  snake =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

solitaire = 5;
poker = 6;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started << done && flag

TRUE & started << options

TRUE << count < temp

flag | flags & error

ERROR && TRUE << options

remember would refer back not seen

  poker =     ____    __    __

  fence =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

english = 4;
dutch = 9;
occult = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & done ^ MASK

error & done == temp

rate + offset || started

bits & length * rate

mask | TRUE || error

remember would refer back not seen

  english =     ____    __    __

  occult =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

verb = 4;
adjective = 5;
string = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask | resource == val

field < resource && finished

rate + num | flags

flag | TRUE - rate

started && TRUE < val

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

  string =     ____    __    __

dress = 5;
shirt = 8;
petrol = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT < length || finished

temp == TRUE && error

VAL == started || TRUE

FINISHED && TRUE - count

TRUE || flag & mask

remember would refer back not seen

  trousers =     ____    __    __

  petrol =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

fork = 9;
hair = 6;
spoon = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < started | STATE

error || 2 - rate

mask & val < n

offset + num * rate

started || TRUE && ERROR

remember would refer back not seen

  fork =     ____    __    __

  hair =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

canal = 6;
stream = 9;
river = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < OFFSET * offset

bits ^ finished && TRUE

offset << resource == n

n == offset < 2

bits ^ state | bits

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  room =     ____    __    __

plumber = 4;
painter = 9;
saddle = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & error && started

state & 0xff % 2

done & state - num

0XFF & mask < 7

0xff & finished << 2

remember would refer back not seen

  painter =     ____    __    __

  plumber =     ____    __    __

  saddle =     ____    __    __

  builder =     ____    __    __

saw = 5;
occult = 8;
hammer = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & field == 7

error & options ^ FLAG

offset + rate * offset

finished & TRUE | started

length + 2 - num

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

  occult =     ____    __    __

blue = 9;
red = 6;
green = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & mask || TRUE

num + 7 < field

num % flags & error

length + count << flag

count + 2 == 7

remember would refer back not seen

  blue =     ____    __    __

  tangent =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

sofa = 5;
propeller = 9;
table = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + state ^ TRUE

LENGTH + 0xff | state

length < resource - 2

num + finished || error

field < state << count

remember would refer back not seen

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  propeller =     ____    __    __

report = 5;
france = 9;
sweden = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options << done & started

LENGTH < resource == temp

0XFF << 2 && FLAG

offset < error ^ state

7 < options | TRUE

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  report =     ____    __    __

  sweden =     ____    __    __

venus = 9;
jupiter = 5;
mars = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < done || TRUE

temp == 7 & bits

error && done & TRUE

done ^ TRUE << 2

field == error && done

remember would refer back not seen

  jupiter =     ____    __    __

  mars =     ____    __    __

  wood =     ____    __    __

  venus =     ____    __    __

pencil = 6;
cow = 5;
sheep = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && error * num

flags ^ error == val

temp == 7 * num

FLAG && done - offset

mask ^ TRUE | state

remember would refer back not seen

  sheep =     ____    __    __

  cow =     ____    __    __

  pencil =     ____    __    __

  pig =     ____    __    __

fly = 5;
bee = 8;
wasp = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == count - 2

error && n < temp

FLAGS ^ TRUE || finished

started && TRUE << rate

mask | 0XFF & error

remember would refer back not seen

  hot =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

sparrow = 9;
plastic = 8;
robin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && finished == temp

flag | done && DONE

error && FINISHED ^ done

finished | state * rate

done && started | mask

remember would refer back not seen

  sparrow =     ____    __    __

  robin =     ____    __    __

  plastic =     ____    __    __

  blackbird =     ____    __    __

apple = 4;
pear = 8;
atom = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || started ^ state

finished | 2 - num

finished && done || finished

finished || started | finished

state | length < N

remember would refer back not seen

  atom =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

hour = 6;
minute = 4;
comb = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG | offset << flag

count * done && finished

rate / 2 - rate

NUM * val < resource

count / length << flags

remember would refer back not seen

  second =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

  comb =     ____    __    __

chestnut = 6;
oak = 4;
elm = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset % rate == temp

rate * count ^ flag

NUM * offset | done

num << length % num

length * TRUE || error

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  chapter =     ____    __    __

  chestnut =     ____    __    __

january = 4;
hair = 9;
june = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE << offset - length

num + count & flags

2 << rate < resource

count + done && error

TRUE << temp == field

remember would refer back not seen

  june =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  hair =     ____    __    __

tail = 8;
heart = 9;
liver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits << 0xff ^ STARTED

2 << TRUE | options

done << flag || done

val == temp < num

field < flag & flags

remember would refer back not seen

  tail =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

solitaire = 4;
plastic = 6;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == val << finished

temp < resource && flag

temp == 7 ^ error

length < 2 % rate

n == state | started

remember would refer back not seen

  scrabble =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

  plastic =     ____    __    __

dutch = 8;
mandarin = 9;
fence = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FIELD == temp || TRUE

mask ^ flags & started

mask ^ finished && flag

mask | state == temp

flags ^ 2 * COUNT

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  fence =     ____    __    __

  dutch =     ____    __    __

wax = 5;
noun = 4;
adjective = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | started ^ 0xff

done ^ length - num

0xff | TRUE || ERROR

options ^ flags < field

done || TRUE & options

remember would refer back not seen

  adjective =     ____    __    __

  wax =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

shirt = 4;
dress = 9;
trousers = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || TRUE && started

flag || done * offset

flag || offset - num

error || length < resource

TRUE || started << 0xff

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  engine =     ____    __    __

spoon = 8;
knife = 4;
petrol = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & error && started

options & rate * count

flag & mask - 2

finished & state < val

done & num << flag

remember would refer back not seen

  knife =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

  petrol =     ____    __    __

stream = 8;
membrane = 5;
river = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & 0xff == n

error & options ^ flags

count + OFFSET / offset

finished & bits | error

RATE + LENGTH - rate

remember would refer back not seen

  membrane =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

saddle = 5;
painter = 4;
plumber = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & TRUE || flag

count + offset < resource

offset * 0xff & state

length + mask << done

length + resource == val

remember would refer back not seen

  builder =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

  saddle =     ____    __    __

screwdriver = 9;
saw = 5;
hammer = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + count ^ started

2 + mask | options

length < 2 - length

2 + rate || done

7 < offset << started

remember would refer back not seen

  hammer =     ____    __    __

  occult =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

pencil = 9;
blue = 4;
green = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | length < field

error & 0xff == 7

resource == n && TRUE

rate * count + 2

num << finished || ERROR

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

  pencil =     ____    __    __

table = 8;
chair = 6;
propeller = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && error | started

started && flag < temp

STARTED & error || flag

temp == resource || TRUE

flag << bits | done

remember would refer back not seen

  sofa =     ____    __    __

  chair =     ____    __    __

  table =     ____    __    __

  propeller =     ____    __    __

sweden = 5;
france = 6;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < n & flag

count + started | done

TEMP < count + rate

started && flags << rate

VAL == field < 2

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  grass =     ____    __    __

jupiter = 5;
engine = 6;
mars = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || error & flags

resource == count * length

STATE & finished && done

done && TRUE & MASK

state ^ finished || error

remember would refer back not seen

  mars =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  engine =     ____    __    __

cow = 9;
sheep = 4;
chapter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || flags | 0xff

error | offset * 2

offset * done << finished

done || TRUE << bits

done & options * num

remember would refer back not seen

  pig =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

  chapter =     ____    __    __

bee = 8;
snake = 9;
fly = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << num && started

flags << length < field

VAL == temp << started

flag | num + rate

started || LENGTH * rate

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  snake =     ____    __    __

wood = 4;
blackbird = 6;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < flag || done

options << started & state

state & bits < val

2 < done | MASK

mask ^ finished & flag

remember would refer back not seen

  wood =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

apple = 9;
membrane = 4;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | bits << num

finished << count * rate

finished && TRUE || started

error || n < temp

num < field * length

remember would refer back not seen

  pear =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

  membrane =     ____    __    __

hour = 9;
minute = 6;
second = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * 2 < n

flag ^ field == 7

options & MASK | mask

field == resource ^ flags

DONE & state ^ TRUE

remember would refer back not seen

  minute =     ____    __    __

  hour =     ____    __    __

  hair =     ____    __    __

  second =     ____    __    __

elm = 6;
saddle = 8;
oak = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || temp == field

FLAG << TRUE ^ flags

finished || TRUE + length

count + rate || TRUE

state | options == n

remember would refer back not seen

  oak =     ____    __    __

  saddle =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

october = 4;
january = 6;
petrol = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + num == val

resource == temp + rate

length % rate | finished

offset + OPTIONS ^ error

error | mask ^ error

remember would refer back not seen

  june =     ____    __    __

  january =     ____    __    __

  petrol =     ____    __    __

  october =     ____    __    __

heart = 8;
liver = 5;
lung = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * resource == field

count * offset && error

finished && length * num

val < 7 ^ bits

state | flag && started

remember would refer back not seen

  report =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

solitaire = 4;
scrabble = 6;
tangent = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < count << flags

error ^ 0xff | TRUE

val == bits | 0xff

TRUE || error && started

num + flag && started

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  tangent =     ____    __    __

mandarin = 5;
english = 9;
atom = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate % bits & flag

val == error & flag

bits ^ state && TRUE

mask ^ OFFSET << length

finished || error ^ flag

remember would refer back not seen

  mandarin =     ____    __    __

  dutch =     ____    __    __

  atom =     ____    __    __

  english =     ____    __    __

noun = 9;
kettle = 6;
verb = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * count ^ done

state | flag || TRUE

2 < length == resource

FLAGS ^ rate + num

error && STARTED ^ done

remember would refer back not seen

  noun =     ____    __    __

  kettle =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

trousers = 4;
dress = 6;
exterior = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | bits & flags

started << resource == temp

flag & mask << 0xff

error && n == resource

started && error + offset

remember would refer back not seen

  exterior =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

knife = 9;
lizard = 4;
fork = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < error && started

error ^ state < OFFSET

num + offset < 7

flag << finished + 2

flags & state + rate

remember would refer back not seen

  lizard =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

river = 4;
stream = 6;
room = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + length & TRUE

count * finished || done

offset + rate % count

2 + length << FLAG

flag ^ error * rate

remember would refer back not seen

  room =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

painter = 9;
occult = 6;
plumber = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & flag && finished

FLAGS & state * 2

0xff & state + NUM

error & FIELD < resource

error & LENGTH << started

remember would refer back not seen

  occult =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

screwdriver = 4;
saw = 6;
tail = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & field == resource

state & mask ^ error

rate + OFFSET * COUNT

state & bits | FINISHED

offset + n < resource

remember would refer back not seen

  hammer =     ____    __    __

  saw =     ____    __    __

  tail =     ____    __    __

  screwdriver =     ____    __    __

blue = 8;
red = 4;
room = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & started || finished

num + 2 << offset

length * count & FLAG

num + temp == val

num + LENGTH ^ bits

remember would refer back not seen

  blue =     ____    __    __

  red =     ____    __    __

  room =     ____    __    __

  green =     ____    __    __

chair = 6;
table = 4;
chapter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + num | flags

offset + error || done

resource < length << num

2 << num & TRUE

rate < resource == temp

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

  chapter =     ____    __    __

sweden = 5;
report = 9;
germany = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STATE << done && flag

val < temp ^ state

finished << mask * count

7 < n | error

n < length || started

remember would refer back not seen

  sweden =     ____    __    __

  report =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

jupiter = 4;
venus = 8;
mars = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == 7 & started

temp == TRUE && started

flag && state & error

done ^ MASK == resource

VAL == num * count

remember would refer back not seen

  mars =     ____    __    __

  membrane =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

atom = 4;
sheep = 6;
pig = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && finished * count

bits ^ state | bits

7 == n + OFFSET

started && rate + length

0xff ^ state || started

remember would refer back not seen

  sheep =     ____    __    __

  atom =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

snake = 4;
bee = 8;
wasp = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == rate < num

TRUE && length < val

OPTIONS | error & finished

error && done << count

BITS | mask && error

remember would refer back not seen

  wasp =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  snake =     ____    __    __

fence = 9;
robin = 8;
blackbird = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && started == temp

error | length * offset

started && mask ^ flag

done | offset + count

done && error | TRUE

remember would refer back not seen

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  fence =     ____    __    __

  robin =     ____    __    __

apple = 4;
exterior = 5;
banana = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE || TRUE | bits

finished | mask < field

flag && finished || error

flag | bits << flags

flag | 7 == field

remember would refer back not seen

  exterior =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

hour = 8;
tangent = 4;
minute = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * 2 && error

2 * offset + 2

rate * num < temp

offset * length << finished

2 * resource == temp

remember would refer back not seen

  hour =     ____    __    __

  second =     ____    __    __

  minute =     ____    __    __

  tangent =     ____    __    __

hot = 4;
chestnut = 5;
oak = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET * num ^ TRUE

offset % length | 0xff

error << offset + rate

2 / error || finished

mask << rate < val

remember would refer back not seen

  hot =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

june = 8;
october = 9;
january = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + error & options

rate << length == RESOURCE

2 + rate && TRUE

error << flags ^ started

offset << FLAG | bits

remember would refer back not seen

  june =     ____    __    __

  october =     ____    __    __

  saddle =     ____    __    __

  january =     ____    __    __

heart = 8;
lung = 6;
liver = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask << bits || started

N < state & started

TEMP == options << mask

val < started && flag

7 == FLAG ^ state

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

  petrol =     ____    __    __

scrabble = 6;
occult = 4;
poker = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field < resource * rate

resource == n | mask

n < 2 + num

7 == finished || FLAG

state ^ bits & TRUE

remember would refer back not seen

  occult =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

english = 5;
lizard = 6;
mandarin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ error && ERROR

flags ^ NUM * rate

0XFF | mask ^ finished

started ^ flag + 2

bits | FINISHED || finished

remember would refer back not seen

  dutch =     ____    __    __

  lizard =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

noun = 5;
string = 6;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ n < length

TRUE || flag & bits

flag ^ flags << FLAGS

flag || started && error

flag || error * rate

remember would refer back not seen

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  string =     ____    __    __

kettle = 6;
trousers = 9;
dress = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || offset + length

started || error < offset

flag || ERROR << DONE

TRUE || val == TEMP

TRUE || error ^ 0xff

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  kettle =     ____    __    __

  dress =     ____    __    __

knife = 9;
spoon = 5;
plastic = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & flags && DONE

options & num * length

started & TRUE + num

flag & options < rate

started & done << offset

remember would refer back not seen

  fork =     ____    __    __

  plastic =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

wheel = 5;
river = 6;
canal = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & finished == RESOURCE

flag & 0xff ^ options

num + offset * 2

flag & error | TRUE

2 + length < 7

remember would refer back not seen

  stream =     ____    __    __

  river =     ____    __    __

  wheel =     ____    __    __

  canal =     ____    __    __

occult = 9;
painter = 8;
builder = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FINISHED & TRUE || started

2 + count << bits

rate % offset & state

rate + temp == TEMP

length + state ^ done

remember would refer back not seen

  plumber =     ____    __    __

  builder =     ____    __    __

  painter =     ____    __    __

  occult =     ____    __    __

hammer = 6;
screwdriver = 4;
saw = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + TRUE | options

rate + done || finished

n < resource << flags

done << error & STARTED

offset < num == RESOURCE

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

  tail =     ____    __    __

green = 6;
red = 8;
blue = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & flag | 0xff

length * num < rate

mask ^ finished << mask

temp == num * length

offset * resource != field

remember would refer back not seen

  occult =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

chair = 6;
sofa = 4;
string = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || 2 << num

offset + resource != val

STARTED ^ num % RATE

temp == field | finished

TRUE | length - num

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  string =     ____    __    __

  sofa =     ____    __    __

france = 4;
pencil = 9;
sweden = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * 0xff & flag

rate % 2 << error

7 == flag ^ TRUE

TRUE ^ options | flags

TRUE << flag & options

remember would refer back not seen

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

  pencil =     ____    __    __

lizard = 8;
mars = 6;
venus = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & state << 2

TRUE || flag - COUNT

2 * flag | 0xff

started | done || TRUE

2 * num - NUM

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  lizard =     ____    __    __

  mars =     ____    __    __

cow = 9;
sheep = 5;
tail = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag << rate - count

val == resource << options

error && done << RATE

rate < num << error

state & rate < 7

remember would refer back not seen

  pig =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

  tail =     ____    __    __

fly = 9;
bee = 6;
wasp = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & options * rate

flags | flag != temp

TRUE << error ^ TRUE

bits ^ started & bits

rate + 2 * rate

remember would refer back not seen

  fly =     ____    __    __

  comb =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

blackbird = 6;
sparrow = 4;
membrane = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < n && error

2 + BITS ^ mask

done && num - count

TRUE && temp < 2

started && finished & 0xff

remember would refer back not seen

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  membrane =     ____    __    __

  robin =     ____    __    __

pear = 5;
hot = 6;
banana = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && length * offset

TRUE | state << error

7 == field || STARTED

offset < flag ^ state

error | TRUE / length

remember would refer back not seen

  hot =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

wax = 6;
second = 5;
hour = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field < n | done

done || bits | options

n < offset - num

flag && TRUE | flag

finished & TRUE || DONE

remember would refer back not seen

  hour =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  wax =     ____    __    __

elm = 6;
chestnut = 4;
oak = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

LENGTH * rate || started

TRUE || length % num

LENGTH << finished | error

done && FLAG != field

error ^ num - length

remember would refer back not seen

  chestnut =     ____    __    __

  exterior =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

october = 6;
january = 4;
saddle = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || finished ^ mask

num % flag && started

bits << state != 7

rate < length * count

count * length ^ options

remember would refer back not seen

  october =     ____    __    __

  january =     ____    __    __

  saddle =     ____    __    __

  june =     ____    __    __

heart = 5;
lung = 8;
engine = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags << rate || done

resource < field || ERROR

resource == done & finished

rate + length - offset

ERROR | num < resource

remember would refer back not seen

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

  engine =     ____    __    __

poker = 6;
solitaire = 4;
scrabble = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | finished && started

started && done || flag

done | flag & error

TRUE ^ finished && TRUE

flag && started ^ TRUE

remember would refer back not seen

  scrabble =     ____    __    __

  snake =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

dutch = 5;
pencil = 9;
english = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + offset & started

TEMP == temp != 7

started & flags ^ TRUE

rate + finished && FLAG

mask ^ OFFSET < FIELD

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  pencil =     ____    __    __

  english =     ____    __    __

noun = 6;
verb = 4;
wheel = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & 2 - count

2 + length | flags

TRUE & BITS && done

TRUE << offset % 2

ERROR ^ n != field

remember would refer back not seen

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  wheel =     ____    __    __

shirt = 6;
petrol = 5;
dress = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options << num < LENGTH

length + flag || error

count < field != n

num << finished && done

bits | started ^ bits

remember would refer back not seen

  petrol =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

fork = 8;
fence = 5;
knife = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE ^ error || started

count + length < NUM

field == n < FIELD

finished || TRUE < 7

state & 0xff != 7

remember would refer back not seen

  fence =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

plastic = 9;
stream = 6;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < count & finished

error || finished && done

temp == 2 - num

7 == temp && TRUE

rate + 2 << options

remember would refer back not seen

  river =     ____    __    __

  plastic =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

fence = 5;
painter = 9;
plumber = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & bits != field

finished & flag && TRUE

ERROR & offset / count

0xff & 2 - length

flags & 0xff < length

remember would refer back not seen

  fence =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

exterior = 6;
saw = 9;
screwdriver = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & state << flags

flags & finished ^ error

offset + flag && TRUE

started & error | options

offset + 2 * length

remember would refer back not seen

  hammer =     ____    __    __

  exterior =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

tail = 5;
green = 9;
red = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & FLAGS || started

rate + offset - count

rate % temp != 7

offset + n < length

length + TRUE << 2

remember would refer back not seen

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  tail =     ____    __    __

table = 5;
sofa = 8;
chair = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + flags ^ error

LENGTH + num | started

n < length * num

count + TRUE || flag

TEMP < 2 - offset

remember would refer back not seen

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  kettle =     ____    __    __

sweden = 6;
france = 8;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << done != field

count < flags << 2

TRUE << mask & flag

length < FINISHED ^ started

field < done | bits

remember would refer back not seen

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

  hot =     ____    __    __

mars = 9;
jupiter = 5;
venus = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < done || error

resource == n != temp

finished && field != n

bits ^ count - RATE

n == done & DONE

remember would refer back not seen

  string =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

cow = 8;
sheep = 5;
pig = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && 0xff & flag

state ^ mask < temp

temp == resource && started

finished && done % 2

error ^ started << rate

remember would refer back not seen

  cow =     ____    __    __

  saddle =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

chapter = 9;
wasp = 8;
fly = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == n * rate

flag && rate - NUM

0xff ^ finished | error

started && field < num

options ^ finished || done

remember would refer back not seen

  fly =     ____    __    __

  bee =     ____    __    __

  chapter =     ____    __    __

  wasp =     ____    __    __

robin = 8;
membrane = 6;
sparrow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && length << offset

flag | TRUE != temp

TRUE && flag ^ done

flag | options & bits

error && TRUE | started

remember would refer back not seen

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

  membrane =     ____    __    __

pencil = 9;
pear = 8;
apple = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || LENGTH << NUM

flags | flag && STARTED

finished && FINISHED || TRUE

TRUE || flags ^ 0xff

mask | 2 * offset

remember would refer back not seen

  pencil =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

hour = 6;
grass = 5;
second = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || flag | state

TRUE | options - count

offset * count & started

count * done && TRUE

offset * num - count

remember would refer back not seen

  second =     ____    __    __

  minute =     ____    __    __

  grass =     ____    __    __

  hour =     ____    __    __

chestnut = 5;
oak = 8;
room = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num / count < rate

rate * mask << finished

offset * count ^ options

offset % length | flags

done << options && error

remember would refer back not seen

  chestnut =     ____    __    __

  room =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

june = 9;
october = 4;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * flag || STARTED

rate << flags % rate

rate + length != field

started << 2 - length

length + count & bits

remember would refer back not seen

  october =     ____    __    __

  occult =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

plastic = 8;
lung = 5;
heart = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate << 0xff < n

flag << offset ^ FLAGS

finished << num | 0xff

TRUE << OPTIONS || done

resource == val - 2

remember would refer back not seen

  plastic =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

scrabble = 8;
poker = 4;
wax = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < field != TEMP

RESOURCE == 2 < 7

val < TRUE & state

field == length << count

field < TRUE && done

remember would refer back not seen

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  wax =     ____    __    __

dutch = 5;
hair = 9;
english = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == VAL ^ options

temp == val | error

7 == finished || done

0xff ^ ERROR != n

bits | num < count

remember would refer back not seen

  english =     ____    __    __

  hair =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

plastic = 5;
noun = 9;
verb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ flag & started

0xff | options << finished

flags ^ TRUE && finished

started | flags ^ mask

error ^ offset * count

remember would refer back not seen

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  plastic =     ____    __    __

shirt = 9;
occult = 4;
dress = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags | started || TRUE

error || 7 != n

started || finished & 0xff

flag || finished && done

started || num * offset

remember would refer back not seen

  trousers =     ____    __    __

  shirt =     ____    __    __

  occult =     ____    __    __

  dress =     ____    __    __

spoon = 5;
fork = 9;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & val != resource

finished & TRUE && STARTED

flags & offset * LENGTH

done & length - OFFSET

finished & offset < val

remember would refer back not seen

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

  wood =     ____    __    __

stream = 9;
pencil = 6;
river = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & rate << 0xff

flags & 0xff ^ TRUE

2 + count && done

finished & flags | state

count + 2 % num

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  pencil =     ____    __    __

builder = 8;
fence = 6;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & done || TRUE

num + rate - length

COUNT * count != temp

NUM + rate < num

rate + num << flags

remember would refer back not seen

  painter =     ____    __    __

  fence =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

screwdriver = 4;
saw = 9;
hammer = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + offset ^ flags

num + state | error

RATE < 7 * length

offset + rate || done

temp < OFFSET - offset

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

  exterior =     ____    __    __

pencil = 6;
green = 5;
blue = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + offset * count

TRUE << offset & done

options | TRUE * rate

TRUE && field != n

count * rate || TRUE

remember would refer back not seen

  pencil =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

chair = 4;
sofa = 6;
petrol = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + started & 0xff

N == val < count

temp == state << OFFSET

done || started < val

done || flag & STATE

remember would refer back not seen

  table =     ____    __    __

  petrol =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

germany = 5;
sweden = 8;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < bits & done

rate << RATE != n

rate < options | bits

temp == bits ^ options

finished || flags | options

remember would refer back not seen

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

  grass =     ____    __    __

venus = 8;
mars = 4;
exterior = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT < 7 && FLAG

resource == bits & started

finished & flags << finished

2 + num < 2

STARTED ^ resource < 7

remember would refer back not seen

  exterior =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

lizard = 4;
sheep = 5;
cow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && flags << num

done ^ 0xff & mask

flag ^ resource != TEMP

count / rate != resource

flag ^ rate << offset

remember would refer back not seen

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  lizard =     ____    __    __

wasp = 8;
fly = 9;
snake = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || finished * 2

error && STARTED + rate

2 << num < N

length + num != field

TRUE ^ flags && finished

remember would refer back not seen

  snake =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

occult = 8;
robin = 5;
sparrow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == 7 * num

done | error ^ state

flag || field != n

bits | flag & bits

finished | flags < length

remember would refer back not seen

  occult =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

fence = 8;
pear = 6;
banana = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || done ^ finished

resource < 2 << options

offset + count || error

2 < count * 2

n == val && started

remember would refer back not seen

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

  fence =     ____    __    __

hour = 6;
membrane = 4;
minute = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && 2 < field

started | count + length

started & state || finished

TRUE << state || started

num * length < resource

remember would refer back not seen

  minute =     ____    __    __

  membrane =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

occult = 6;
oak = 4;
elm = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && flag || started

count / rate & FLAGS

options ^ started + count

flag && finished | flags

rate / started && FLAG

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  occult =     ____    __    __

june = 9;
january = 4;
october = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE << done + offset

state | done && flag

length * num + count

count % MASK ^ error

options | 0xff << 2

remember would refer back not seen

  kettle =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

lung = 9;
pencil = 5;
heart = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || error && done

7 == val + rate

7 < temp + num

error && started * offset

flag && done ^ flags

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

  pencil =     ____    __    __

solitaire = 9;
scrabble = 5;
tangent = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * length << rate

done << 2 * rate

error & num + 2

TRUE & N != TEMP

offset < flag ^ STARTED

remember would refer back not seen

  tangent =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

english = 5;
mandarin = 9;
dutch = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + RATE << state

mask ^ 2 * length

rate < finished || flag

error | finished || TRUE

error & DONE < field

remember would refer back not seen

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  room =     ____    __    __

wheel = 9;
noun = 8;
verb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && MASK & flags

error ^ finished || started

finished & flag | mask

0xff | flag != n

temp == flag | error

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

  wheel =     ____    __    __

trousers = 9;
shirt = 6;
wax = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 % mask | FINISHED

done & started ^ done

2 + started && done

flag || TRUE << options

flag ^ 0xff | error

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

  wax =     ____    __    __

fork = 6;
atom = 9;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state << flag ^ flags

2 + num | flags

flags & options && STARTED

bits << mask | done

DONE & count * 2

remember would refer back not seen

  atom =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

canal = 6;
stream = 4;
propeller = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << started && flag

field < n != val

val == 7 != resource

flag || 2 + RATE

rate + count ^ error

remember would refer back not seen

  river =     ____    __    __

  propeller =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

plumber = 4;
wax = 9;
builder = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & field != 7

flag & flags && TRUE

FLAGS & offset * 2

TRUE & finished + length

finished & flag < num

remember would refer back not seen

  builder =     ____    __    __

  plumber =     ____    __    __

  wax =     ____    __    __

  painter =     ____    __    __

screwdriver = 4;
hammer = 5;
string = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & error << done

state & flags ^ options

offset + 2 && done

done & mask | flags

2 + length * offset

remember would refer back not seen

  screwdriver =     ____    __    __

  string =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

red = 4;
blue = 5;
membrane = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & started || error

count + COUNT < 7

count * length != temp

num + rate << 0xff

2 + offset ^ TRUE

remember would refer back not seen

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  membrane =     ____    __    __

chair = 4;
sofa = 5;
grass = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + bits | flag

offset + length || done

resource < offset + count

length << n != val

7 < offset << 2

remember would refer back not seen

  grass =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

germany = 5;
france = 6;
sweden = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << flags & 0xff

field < num ^ finished

length << offset && TRUE

num < 0xff | flags

length < rate || error

remember would refer back not seen

  france =     ____    __    __

  germany =     ____    __    __

  hair =     ____    __    __

  sweden =     ____    __    __

snake = 4;
venus = 5;
mars = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == 7 != resource

val == n & finished

error && done != resource

FINISHED ^ rate < val

field == n && flag

remember would refer back not seen

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

  snake =     ____    __    __

pencil = 9;
sheep = 5;
pig = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && TRUE & flags

done ^ started << flag

7 == VAL / rate

started && error * 2

0xff ^ options | 0xff

remember would refer back not seen

  cow =     ____    __    __

  pencil =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

bee = 4;
fly = 9;
hot = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == RESOURCE + num

done && FINISHED + num

finished ^ FLAG || started

STARTED && temp < LENGTH

mask | 7 != resource

remember would refer back not seen

  hot =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

sparrow = 8;
robin = 6;
blackbird = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && finished << started

TRUE | options & error

error && FLAGS ^ bits

0xff | finished && error

done && flag | 0XFF

remember would refer back not seen

  robin =     ____    __    __

  comb =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

pear = 6;
apple = 8;
banana = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || error ^ flag

finished | flag * 2

error && flag || TRUE

done || flag | started

flag | mask + length

remember would refer back not seen

  banana =     ____    __    __

  report =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

hour = 6;
wood = 5;
minute = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | 2 < resource

2 * state & FINISHED

rate / offset && done

count % length + NUM

num * val < num

remember would refer back not seen

  minute =     ____    __    __

  wood =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

occult = 8;
elm = 5;
oak = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length / done << state

length % 2 ^ TRUE

OFFSET * offset | flag

options << length * offset

2 * count || ERROR

remember would refer back not seen

  occult =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  chestnut =     ____    __    __

room = 9;
january = 6;
october = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << offset + rate

count + 7 != field

BITS << num < count

length + offset & TRUE

flag << error ^ flags

remember would refer back not seen

  june =     ____    __    __

  room =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

lung = 4;
heart = 5;
liver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags << 2 | finished

num << flags || finished

length < val != temp

n == val < num

count < error & options

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  tail =     ____    __    __

  lung =     ____    __    __

plastic = 5;
poker = 9;
scrabble = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == 7 << flag

offset < started && error

field == 7 ^ TRUE

temp < resource * rate

field == mask | flags

remember would refer back not seen

  scrabble =     ____    __    __

  plastic =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

pencil = 8;
dutch = 6;
english = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == temp || TRUE

bits ^ resource != val

mask ^ STATE & options

flag | ERROR << 0xff

flag ^ started && done

remember would refer back not seen

  dutch =     ____    __    __

  pencil =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

noun = 5;
verb = 4;
adjective = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | 0xff ^ finished

mask ^ state * count

options | started || finished

options ^ done + rate

FLAG || flag != temp

remember would refer back not seen

  propeller =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

shirt = 8;
dress = 6;
chapter = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE || FLAG & flag

flag || started && flag

error || 2 * offset

TRUE || finished + offset

finished || TRUE < num

remember would refer back not seen

  trousers =     ____    __    __

  shirt =     ____    __    __

  chapter =     ____    __    __

  dress =     ____    __    __

fork = 8;
knife = 5;
petrol = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & bits != field

options & started && ERROR

ERROR & started * num

TRUE & error + count

mask & started < temp

remember would refer back not seen

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

  petrol =     ____    __    __

river = 5;
fence = 9;
stream = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & finished << done

state & flag ^ mask

offset + num && done

flag & started | finished

length + rate / num

remember would refer back not seen

  river =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  fence =     ____    __    __

builder = 8;
painter = 9;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & OPTIONS || started

offset + resource < length

rate * length != resource

num + error << flag

num + done ^ error

remember would refer back not seen

  builder =     ____    __    __

  wax =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

saw = 6;
screwdriver = 8;
string = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + BITS | 0xff

count + error || TRUE

length < num + count

done << 7 != n

count < 2 << mask

remember would refer back not seen

  string =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

green = 6;
grass = 4;
blue = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == val || FINISHED

OPTIONS & error ^ started

error | BITS & 0xff

done ^ finished && flag

flag && started | finished

remember would refer back not seen

  grass =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

table = 5;
tangent = 6;
sofa = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits | finished - COUNT

rate * 2 < val

done | rate * length

FINISHED && error == field

mask << started & 0xff

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

  tangent =     ____    __    __

germany = 8;
sweden = 5;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + count << length

done ^ resource == field

length * 7 == resource

error && flag << count

TRUE ^ started | flags

remember would refer back not seen

  sweden =     ____    __    __

  germany =     ____    __    __

  wood =     ____    __    __

  france =     ____    __    __

mars = 9;
hot = 6;
jupiter = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + count && TRUE

started && 0xff ^ TRUE

TRUE && count * rate

7 < val * 2

error & flags | done

remember would refer back not seen

  hot =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

cow = 9;
pig = 4;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options | n == resource

count < length == val

started && finished - length

temp == field & options

started ^ 2 - offset

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  kettle =     ____    __    __

  sheep =     ____    __    __

fly = 5;
wasp = 4;
room = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * 2 || TRUE

started || finished << 0xff

offset + num || finished

num + count - num

temp == n && done

remember would refer back not seen

  room =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

sparrow = 5;
blackbird = 6;
robin = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & flag << state

0xff | state << bits

flag && count < 7

started || offset < count

num * offset << STARTED

remember would refer back not seen

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

  wax =     ____    __    __

pear = 9;
banana = 6;
apple = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | done || error

done << mask | 0xff

length < flag || TRUE

temp < TRUE & flags

7 < rate && started

remember would refer back not seen

  membrane =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

second = 9;
hour = 5;
hair = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < started ^ 0xff

val == rate - 2

started | options ^ TRUE

done << options == field

error || STARTED && done

remember would refer back not seen

  minute =     ____    __    __

  hour =     ____    __    __

  hair =     ____    __    __

  second =     ____    __    __

chestnut = 4;
elm = 8;
atom = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << count % num

2 + length * count

done || TRUE == FIELD

flags ^ count * rate

0xff << count ^ mask

remember would refer back not seen

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

  atom =     ____    __    __

june = 6;
lizard = 8;
january = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && done || finished

flags & NUM % offset

num * offset && done

bits << TRUE && flag

started || finished / num

remember would refer back not seen

  october =     ____    __    __

  lizard =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

lung = 9;
heart = 5;
saddle = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & done || flag

OFFSET + 7 < field

2 + flag & started

temp == state | TRUE

count * num & TRUE

remember would refer back not seen

  heart =     ____    __    __

  lung =     ____    __    __

  saddle =     ____    __    __

  liver =     ____    __    __

solitaire = 9;
scrabble = 5;
chapter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || TRUE & 0xff

2 + done | mask

flag | 0xff && TRUE

temp < num - count

field == state ^ done

remember would refer back not seen

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  chapter =     ____    __    __

english = 6;
exterior = 4;
dutch = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT < length | mask

finished & count < num

rate * flag | bits

flag || TRUE - num

bits & started == val

remember would refer back not seen

  exterior =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

verb = 8;
petrol = 4;
adjective = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask ^ flag & state

FLAG & finished && started

2 << rate - count

FIELD == rate < NUM

count + length ^ flags

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  petrol =     ____    __    __

  verb =     ____    __    __

shirt = 8;
dress = 5;
comb = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ val < 7

resource == N * OFFSET

state << temp < n

offset + count == RESOURCE

bits ^ FLAG << 2

remember would refer back not seen

  comb =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

spoon = 5;
knife = 9;
fork = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && flag & error

length * count ^ flags

TRUE || done ^ finished

started & count - offset

length / count - OFFSET

remember would refer back not seen

  tail =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

report = 5;
stream = 8;
river = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < field << finished

0xff | rate < resource

flag || bits | FINISHED

error ^ mask || finished

val == error << num

remember would refer back not seen

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

  report =     ____    __    __

painter = 8;
report = 5;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & done && error

TRUE & flag * 2

finished & error - rate

TRUE & mask < 2

options & bits << 2

remember would refer back not seen

  builder =     ____    __    __

  painter =     ____    __    __

  report =     ____    __    __

  plumber =     ____    __    __

plastic = 8;
hammer = 9;
saw = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & val == 7

started & mask ^ flags

rate + num * length

0xff & TRUE | mask

num + rate - count

remember would refer back not seen

  plastic =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

green = 8;
red = 9;
snake = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & TRUE || finished

2 + val < num

offset * 2 & flag

RATE + length << num

count + NUM == RESOURCE

remember would refer back not seen

  snake =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

table = 9;
chapter = 6;
chair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + num ^ FLAGS

OFFSET + count | bits

length < 2 - num

num + 2 || TRUE

7 < state << flag

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  chapter =     ____    __    __

  sofa =     ____    __    __

france = 6;
sweden = 8;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff << started & error

num < count == field

2 << flags && flag

resource < TRUE ^ bits

rate < options | mask

remember would refer back not seen

  engine =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

kettle = 8;
mars = 9;
venus = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < field || finished

7 == started & 0xff

error && mask & finished

finished ^ done << bits

field == error && started

remember would refer back not seen

  kettle =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

pig = 6;
wheel = 8;
sheep = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && TRUE * count

started ^ error == RESOURCE

resource == rate * 2

error && TRUE - num

error ^ bits | error

remember would refer back not seen

  wheel =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

comb = 9;
fly = 6;
bee = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TEMP == offset - 2

STARTED && done < OFFSET

finished ^ TRUE || error

finished && length << 2

state | DONE & state

remember would refer back not seen

  comb =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

sparrow = 9;
wood = 5;
robin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && error == temp

flag | STATE && done

FINISHED && error ^ finished

TRUE | rate * length

flag && flags | done

remember would refer back not seen

  wood =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

pear = 6;
banana = 5;
apple = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || finished ^ TRUE

started | 0xff - 2

finished && done || error

finished || TRUE | mask

flags | temp < val

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

  saddle =     ____    __    __

exterior = 9;
minute = 4;
second = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | FLAGS << 2

num * 2 && TRUE

num * length - rate

length * 2 < num

length * 2 << count

remember would refer back not seen

  second =     ____    __    __

  exterior =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

hair = 8;
chestnut = 6;
elm = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * temp == n

rate * offset ^ state

length * 2 | flags

TRUE << num * rate

length * 2 || started

remember would refer back not seen

  hair =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

january = 4;
october = 5;
grass = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask << length - offset

OFFSET + count & flag

FINISHED << length < val

length + started && done

flags << resource == 7

remember would refer back not seen

  grass =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

lizard = 9;
lung = 8;
heart = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << length ^ FLAG

FLAGS << 0xff | started

flags << done || finished

field == val < RATE

VAL < num & done

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  lizard =     ____    __    __

  heart =     ____    __    __

poker = 4;
solitaire = 6;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == bits << TRUE

field < error && finished

val == 7 ^ mask

7 < n * num

n == field | options

remember would refer back not seen

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  tangent =     ____    __    __

english = 6;
string = 8;
mandarin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

VAL == field || started

mask ^ done & TRUE

0xff ^ state && TRUE

mask | temp == 7

flag ^ count * 2

remember would refer back not seen

  mandarin =     ____    __    __

  dutch =     ____    __    __

  string =     ____    __    __

  english =     ____    __    __

adjective = 4;
noun = 5;
hot = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | TRUE ^ 0xff

0xff ^ options - length

STATE | 0xff || error

options ^ rate < length

error || FLAG & bits

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

  hot =     ____    __    __

dress = 9;
shirt = 8;
pencil = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || started && flag

flag || count * num

done || length - RATE

flag || TRUE < FIELD

finished || bits << TRUE

remember would refer back not seen

  trousers =     ____    __    __

  dress =     ____    __    __

  pencil =     ____    __    __

  shirt =     ____    __    __

spoon = 6;
knife = 5;
fork = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & flag && finished

flag & bits * offset

flags & finished - rate

state & error < field

0xff & flags << mask

remember would refer back not seen

  fork =     ____    __    __

  wax =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

stream = 8;
river = 9;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & n == FIELD

bits & TRUE ^ mask

RATE + num * COUNT

state & flags | started

2 + count - rate

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  plastic =     ____    __    __

builder = 9;
report = 6;
painter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & error || done

NUM + count < field

2 * finished & done

num + offset << num

num + 7 == resource

remember would refer back not seen

  painter =     ____    __    __

  report =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

hammer = 8;
screwdriver = 5;
plastic = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + offset ^ flags

offset + FINISHED | ERROR

TEMP < length - offset

offset + done || TRUE

2 < flags << length

remember would refer back not seen

  plastic =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

chapter = 6;
blue = 5;
red = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE || flag ^ flags

NUM < offset / rate

mask ^ flag != resource

length + 2 ^ mask

flag | finished || started

remember would refer back not seen

  chapter =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

wheel = 6;
table = 9;
chair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count / offset << flags

started || done * rate

0xff << started & 0xff

done << num != val

length / offset && error

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  wheel =     ____    __    __

  sofa =     ____    __    __

sweden = 5;
tail = 8;
germany = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & finished | state

TRUE ^ flag || FLAG

temp == n != val

length + num / length

offset + length - rate

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  tail =     ____    __    __

mars = 9;
room = 8;
jupiter = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < 2 || TRUE

num < field << bits

temp < started && flag

started && 7 != n

length + started & flag

remember would refer back not seen

  room =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

tangent = 4;
pig = 6;
cow = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && state ^ flag

MASK | FIELD < field

started & rate * 2

length + flag || done

finished | started && done

remember would refer back not seen

  pig =     ____    __    __

  cow =     ____    __    __

  tangent =     ____    __    __

  sheep =     ____    __    __

occult = 4;
bee = 8;
wasp = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < n ^ ERROR

field == resource || flag

count * rate != n

finished && length < VAL

count < num & 0XFF

remember would refer back not seen

  wasp =     ____    __    __

  occult =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

sparrow = 5;
robin = 4;
blackbird = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == started << OFFSET

mask & error ^ TRUE

error && finished | error

0xff ^ rate - offset

TRUE ^ error & flags

remember would refer back not seen

  hot =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

propeller = 4;
pear = 6;
banana = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + STARTED && finished

offset + flags | state

rate * done ^ state

flag || finished && error

started || done << mask

remember would refer back not seen

  apple =     ____    __    __

  propeller =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

minute = 4;
hour = 5;
occult = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == resource < temp

finished || TRUE != val

done || finished - count

finished | val != n

count * num - COUNT

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  occult =     ____    __    __

elm = 8;
oak = 6;
chestnut = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && flag || started

mask & TRUE || done

done & field < count

mask & rate - count

error | finished * offset

remember would refer back not seen

  chestnut =     ____    __    __

  pencil =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

january = 9;
june = 5;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags << FLAG && started

flag & flags != resource

started | 2 - length

LENGTH * rate | error

error ^ length * count

remember would refer back not seen

  kettle =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

heart = 4;
lung = 5;
liver = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ options && error

error && 2 - length

DONE && error % rate

TRUE | mask & flags

field < count | state

remember would refer back not seen

  lung =     ____    __    __

  heart =     ____    __    __

  pencil =     ____    __    __

  liver =     ____    __    __

comb = 5;
solitaire = 4;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && flag & mask

0xff | TRUE ^ error

2 << num < offset

LENGTH * mask & options

LENGTH + num < 7

remember would refer back not seen

  poker =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  comb =     ____    __    __

english = 6;
exterior = 4;
dutch = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ done | 0xff

val == temp & state

error || TRUE & flags

offset + 2 << num

RATE << offset | done

remember would refer back not seen

  dutch =     ____    __    __

  english =     ____    __    __

  exterior =     ____    __    __

  mandarin =     ____    __    __

engine = 5;
noun = 4;
verb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field < length - count

n == TEMP | finished

bits & TRUE && finished

MASK | length << 0xff

rate * TEMP < count

remember would refer back not seen

  verb =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

  engine =     ____    __    __

shirt = 4;
trousers = 6;
dress = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

LENGTH + rate != 7

rate << count ^ flag

count % finished || error

flag ^ state << finished

val == n && started

remember would refer back not seen

  dress =     ____    __    __

  trousers =     ____    __    __

  plastic =     ____    __    __

  shirt =     ____    __    __

lizard = 8;
fork = 4;
spoon = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

N < 2 != 7

TRUE << mask - RATE

field == temp - offset

temp == resource / 2

field == 7 ^ mask

remember would refer back not seen

  fork =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

  lizard =     ____    __    __

wood = 8;
canal = 6;
river = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || started | flags

started << options * num

finished || error < count

TRUE && 2 << 0xff

flag & started << 2

remember would refer back not seen

  stream =     ____    __    __

  wood =     ____    __    __

  canal =     ____    __    __

  river =     ____    __    __

builder = 5;
plumber = 6;
painter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & val != resource

flags & flag && started

bits & done / count

DONE & TRUE - count

error & 7 < num

remember would refer back not seen

  plumber =     ____    __    __

  builder =     ____    __    __

  painter =     ____    __    __

  hair =     ____    __    __

screwdriver = 8;
petrol = 6;
hammer = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & started << done

MASK & mask ^ finished

length + 2 && finished

0XFF & DONE | flags

2 + rate * count

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  petrol =     ____    __    __

  hammer =     ____    __    __

green = 9;
blue = 8;
report = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & 0xff || flag

RATE + 2 - offset

num * RATE != n

length + count < 7

num + 0xff << COUNT

remember would refer back not seen

  blue =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

  report =     ____    __    __

chair = 5;
chapter = 4;
table = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM + count ^ mask

rate + TRUE | 0xff

length < count * rate

num + count || finished

n < field - count

remember would refer back not seen

  table =     ____    __    __

  chapter =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

france = 9;
germany = 5;
pencil = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT << field != 7

num < val << finished

error << mask & started

OFFSET < 7 ^ done

RESOURCE < field | 0xff

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  pencil =     ____    __    __

  sweden =     ____    __    __

mars = 8;
string = 6;
jupiter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < field || finished

VAL == field != val

started && TRUE != resource

TRUE ^ length - rate

resource == temp & error

remember would refer back not seen

  string =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

pig = 5;
cow = 9;
sheep = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && started & TRUE

error ^ VAL < NUM

resource == finished && TRUE

finished && count * num

finished ^ state << flag

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  kettle =     ____    __    __

fly = 9;
bee = 4;
propeller = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == val % rate

error && length - 2

FLAG ^ options | bits

flag && done < 2

options ^ started || finished

remember would refer back not seen

  wasp =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  propeller =     ____    __    __

blackbird = 9;
comb = 5;
robin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && done << TRUE

started | TEMP != 7

TRUE && 0xff ^ error

finished | state & finished

error && started | finished

remember would refer back not seen

  comb =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

banana = 4;
apple = 9;
pear = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || TRUE << count

finished | error && finished

finished && flag || started

error || bits ^ options

done | count * rate

remember would refer back not seen

  banana =     ____    __    __

  tail =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

hour = 4;
minute = 6;
second = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || started | options

started | count - offset

rate * options & bits

length / 2 && DONE

offset * 2 - offset

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  pencil =     ____    __    __

oak = 4;
lizard = 6;
chestnut = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 / val < field

NUM * 0xff << done

2 * started ^ flags

offset * 2 | finished

state << TRUE && started

remember would refer back not seen

  lizard =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  chestnut =     ____    __    __

january = 8;
june = 5;
plastic = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * rate || error

2 << count * length

length + 7 != FIELD

2 << offset - rate

count + flags & ERROR

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

  plastic =     ____    __    __

heart = 4;
liver = 8;
lung = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error << num < resource

started << rate ^ TRUE

count << TRUE | bits

state << flags || started

7 == temp - length

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

  wax =     ____    __    __

solitaire = 5;
hot = 4;
poker = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < 7 != RESOURCE

field == n < val

n < flags & done

VAL == flag << rate

7 < started && error

remember would refer back not seen

  poker =     ____    __    __

  hot =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

engine = 5;
dutch = 6;
mandarin = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == 0xff ^ started

temp == DONE | flag

val == resource || started

finished ^ field != FIELD

bits | flag < resource

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  engine =     ____    __    __

exterior = 9;
verb = 4;
adjective = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ flags & finished

0xff | state << 2

flags ^ mask && flag

finished | started ^ flags

flag ^ offset * rate

remember would refer back not seen

  noun =     ____    __    __

  exterior =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

trousers = 8;
shirt = 6;
plastic = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | state || error

finished || 7 != val

started || bits & error

flag || TRUE && done

done || error / offset

remember would refer back not seen

  trousers =     ____    __    __

  plastic =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

knife = 8;
spoon = 4;
fork = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & options != n

TRUE & options && TRUE

TRUE & offset % 2

flags & 0xff - num

0xff & error < rate

remember would refer back not seen

  knife =     ____    __    __

  spoon =     ____    __    __

  wood =     ____    __    __

  fork =     ____    __    __

canal = 9;
river = 8;
stream = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0XFF & TRUE << flags

finished & flag ^ 0xff

count + error && flag

state & done | mask

offset + count * rate

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  membrane =     ____    __    __

  river =     ____    __    __

painter = 4;
builder = 8;
plumber = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & done || TRUE

rate + length - offset

count * TEMP != 7

offset + n < val

length + 2 << rate

remember would refer back not seen

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

  hair =     ____    __    __

hammer = 5;
saw = 9;
screwdriver = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + length ^ DONE

count + flag | bits

field < temp * length

length + error || finished

n < N - offset

remember would refer back not seen

  hammer =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

  petrol =     ____    __    __

red = 9;
green = 5;
pencil = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + count & flag

7 < state << error

0XFF & flag < offset

0xff & bits << 2

TRUE | finished ^ 0xff

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

  pencil =     ____    __    __

chair = 8;
table = 4;
snake = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < temp != resource

flag || offset << count

started && rate < RATE

options ^ bits | TRUE

resource == done && finished

remember would refer back not seen

  table =     ____    __    __

  snake =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

tangent = 4;
germany = 9;
france = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ field != N

TRUE || done | options

length + LENGTH < count

OPTIONS & finished | error

finished && num * rate

remember would refer back not seen

  sweden =     ____    __    __

  tangent =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

venus = 5;
mars = 8;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE << flag && done

mask & TRUE && finished

offset * num != 7

n == resource < rate

2 << finished & done

remember would refer back not seen

  venus =     ____    __    __

  kettle =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

sheep = 5;
pig = 8;
cow = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == n - count

FINISHED ^ count < val

n == resource | TRUE

DONE || temp != 7

flags | started != 7

remember would refer back not seen

  wax =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

bee = 9;
wasp = 8;
propeller = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + finished ^ options

started && 7 != n

num < temp ^ started

num + n != RESOURCE

TRUE & state || started

remember would refer back not seen

  fly =     ____    __    __

  propeller =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

membrane = 6;
sparrow = 9;
robin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * offset - COUNT

error && FINISHED & done

flag && FLAG - num

count << BITS ^ flags

flag && error || done

remember would refer back not seen

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

  membrane =     ____    __    __

apple = 4;
atom = 5;
banana = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT < temp * num

started || offset - num

started & num * rate

offset + 2 | DONE

state | finished % offset

remember would refer back not seen

  pear =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  atom =     ____    __    __

hour = 5;
minute = 9;
second = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || 0XFF & flag

offset + rate - offset

offset < TRUE | 0xff

rate + error || finished

error << temp != TEMP

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  hair =     ____    __    __

elm = 4;
chestnut = 5;
engine = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + length << num

TRUE && error | state

finished << offset * length

started | error && ERROR

TRUE ^ count * 2

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  engine =     ____    __    __

june = 4;
october = 8;
plastic = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | bits || done

flag | 2 - length

flag ^ rate - offset

RESOURCE < resource - count

offset + 2 * offset

remember would refer back not seen

  plastic =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

heart = 5;
lung = 8;
liver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < OPTIONS & flags

bits << options < length

temp == OPTIONS ^ flags

flags & error != temp

mask ^ done || flag

remember would refer back not seen

  lung =     ____    __    __

  fence =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

scrabble = 6;
occult = 5;
poker = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || flag && error

done || started % offset

DONE && finished << done

count * length << finished

RATE * 2 ^ done

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  occult =     ____    __    __

english = 8;
mandarin = 4;
plastic = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < offset || started

options & bits - length

field == val << flag

error || done ^ finished

offset << finished | TRUE

remember would refer back not seen

  plastic =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

saddle = 6;
adjective = 5;
noun = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == n & flags

length / done & flag

LENGTH * finished && FLAG

MASK | mask << flags

count * length < resource

remember would refer back not seen

  verb =     ____    __    __

  noun =     ____    __    __

  saddle =     ____    __    __

  adjective =     ____    __    __

trousers = 5;
dress = 6;
shirt = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && options ^ flag

offset << finished - length

flag ^ started & state

bits | state & started

7 == num * 2

remember would refer back not seen

  room =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

petrol = 8;
fork = 9;
knife = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == val != field

count * done || FINISHED

7 < ERROR && started

mask ^ rate << error

0xff & bits ^ flag

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  petrol =     ____    __    __

  spoon =     ____    __    __

canal = 8;
wood = 5;
stream = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || rate < count

rate * RATE | options

TRUE | field < rate

field == started || flag

bits << length || flag

remember would refer back not seen

  canal =     ____    __    __

  wood =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

string = 4;
plumber = 6;
builder = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & started != temp

options & finished && TRUE

bits & 2 * length

0xff & OPTIONS - offset

flag & 2 < num

remember would refer back not seen

  builder =     ____    __    __

  string =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

saw = 5;
hammer = 8;
plastic = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STATE & TRUE << length

error & bits ^ TRUE

2 + finished && error

error & STARTED | error

rate + count * length

remember would refer back not seen

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  plastic =     ____    __    __

  saw =     ____    __    __

blue = 4;
hot = 6;
red = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS & started || flag

2 + rate - offset

count * rate != resource

num + offset < temp

2 + offset << FINISHED

remember would refer back not seen

  red =     ____    __    __

  hot =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

sofa = 9;
chair = 8;
table = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + flag ^ TRUE

length + started | mask

2 < N % 2

2 + count || TRUE

temp < rate - 2

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  grass =     ____    __    __

  sofa =     ____    __    __

wax = 5;
sweden = 6;
france = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished << 7 != field

count < done << rate

rate << finished & started

n < count ^ finished

field < 0xff | 0XFF

remember would refer back not seen

  wax =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

mars = 9;
jupiter = 4;
venus = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < n || started

temp == 7 != temp

TRUE && temp != resource

BITS ^ mask - rate

val == 7 & mask

remember would refer back not seen

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

  tangent =     ____    __    __

cow = 4;
sheep = 5;
petrol = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && error & TRUE

options ^ state < resource

n == flag && done

flag && 2 * count

error ^ TRUE << done

remember would refer back not seen

  cow =     ____    __    __

  petrol =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

bee = 5;
wasp = 4;
fly = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == count % num

flag && finished - rate

done ^ flag | bits

finished && count < n

flags ^ done || started

remember would refer back not seen

  bee =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

  hair =     ____    __    __

robin = 4;
propeller = 5;
blackbird = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR && flag << 2

done | n != temp

DONE && TRUE ^ started

options | bits & error

error && mask | error

remember would refer back not seen

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

  propeller =     ____    __    __

apple = 9;
banana = 4;
pear = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || started << error

mask | flag && done

flag && TRUE || error

finished || error ^ bits

done | 2 * rate

remember would refer back not seen

  lizard =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

second = 8;
minute = 4;
hour = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || FINISHED | TRUE

error | OFFSET - rate

2 * OFFSET & bits

num * finished && started

RATE % offset - 2

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  pencil =     ____    __    __

  hour =     ____    __    __

chestnut = 4;
elm = 6;
plastic = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * offset < field

num * offset << count

length * 0xff ^ state

length * options | 0XFF

DONE << finished && STARTED

remember would refer back not seen

  chestnut =     ____    __    __

  plastic =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

january = 5;
june = 9;
october = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * flag || finished

0xff << started * 2

COUNT + 7 != N

state << mask - rate

offset + options & 0xff

remember would refer back not seen

  atom =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

heart = 8;
lung = 6;
snake = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask << offset < 2

flags << count ^ error

bits << mask | flag

flag << offset || error

temp == field - length

remember would refer back not seen

  lung =     ____    __    __

  snake =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

solitaire = 6;
scrabble = 9;
tail = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate < n != field

n == NUM < 2

n < temp & flags

val == temp << count

num < field && flag

remember would refer back not seen

  tail =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

english = 5;
mandarin = 6;
dutch = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == temp ^ FINISHED

7 == n | TRUE

temp == n || TRUE

0xff ^ bits != field

state | done < temp

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  report =     ____    __    __

verb = 6;
adjective = 8;
noun = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits ^ STATE & flags

state | mask << done

0xff ^ TRUE && finished

bits | options ^ state

bits ^ 2 % length

remember would refer back not seen

  engine =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

dress = 5;
trousers = 4;
wood = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | flags || error

finished || resource != val

error || finished & OPTIONS

finished || TRUE && STARTED

error || flag * rate

remember would refer back not seen

  wood =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

spoon = 5;
fence = 9;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & val != 7

finished & started && finished

done & flag / num

finished & FLAG - length

flags & DONE < num

remember would refer back not seen

  fence =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

river = 9;
kettle = 4;
stream = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & offset << bits

error & finished ^ TRUE

length + 2 && done

mask & options | 0xff

length + 2 % offset

remember would refer back not seen

  kettle =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

builder = 8;
painter = 5;
plumber = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & started || error

offset + length - count

OFFSET * 2 != n

2 + rate < field

2 + count << error

remember would refer back not seen

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  string =     ____    __    __

plastic = 5;
screwdriver = 8;
hammer = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + bits ^ options

rate + num | flag

field < resource / num

rate + count || TRUE

2 < field - 2

remember would refer back not seen

  hammer =     ____    __    __

  plastic =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

blue = 4;
plastic = 8;
green = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num - offset * rate

val != finished & done

2 - offset != val

n < FIELD * offset

error & FLAGS * offset

remember would refer back not seen

  red =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  plastic =     ____    __    __

petrol = 6;
table = 5;
sofa = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << flags && TRUE

TRUE & FLAG << finished

7 != field < temp

error || n != temp

flag | TRUE ^ options

remember would refer back not seen

  table =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

  petrol =     ____    __    __

germany = 8;
exterior = 4;
sweden = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * rate != field

val != flag << TRUE

started ^ error | DONE

VAL != resource || flag

count / offset < field

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  exterior =     ____    __    __

jupiter = 6;
mars = 4;
venus = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & started ^ mask

flags | state - length

rate << BITS ^ TRUE

MASK << TRUE - offset

flag << finished | state

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  occult =     ____    __    __

cow = 6;
sheep = 8;
snake = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - 2 << rate

bits ^ length - rate

2 * num & done

FIELD != 2 - count

0xff & flag || TRUE

remember would refer back not seen

  pig =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

  snake =     ____    __    __

fly = 4;
wasp = 5;
comb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || TRUE && ERROR

bits ^ TRUE && finished

started & 0xff && done

bits & finished != field

temp != error ^ flag

remember would refer back not seen

  wasp =     ____    __    __

  comb =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

blackbird = 6;
saddle = 9;
robin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - offset < field

2 - offset & 0xff

num * offset << BITS

flags & 2 - COUNT

offset % state | started

remember would refer back not seen

  robin =     ____    __    __

  blackbird =     ____    __    __

  saddle =     ____    __    __

  sparrow =     ____    __    __

apple = 5;
engine = 6;
banana = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | done || TRUE

error && TRUE - 2

rate % count - length

0XFF ^ finished & TRUE

OPTIONS ^ flag || done

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  engine =     ____    __    __

  pear =     ____    __    __

second = 5;
report = 8;
hour = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || bits & options

offset < resource | state

done || finished ^ flags

length < done & OPTIONS

temp < 2 || error

remember would refer back not seen

  minute =     ____    __    __

  report =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

elm = 6;
chestnut = 4;
wood = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * 2 || flag

bits ^ error * offset

resource != started && done

error && resource != n

count < 2 - offset

remember would refer back not seen

  wood =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

june = 5;
october = 8;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && finished || started

flag || ERROR < val

NUM * rate ^ TRUE

rate - num ^ options

done << error || DONE

remember would refer back not seen

  october =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

  kettle =     ____    __    __

heart = 6;
liver = 5;
lung = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && ERROR < n

0xff & FLAG < offset

started ^ n != val

rate << finished * RATE

started << 7 != N

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  wax =     ____    __    __

  heart =     ____    __    __

hair = 5;
solitaire = 4;
scrabble = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < n ^ state

n != 7 | mask

offset - LENGTH | flags

TRUE || mask << rate

done || started - num

remember would refer back not seen

  scrabble =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

  hair =     ____    __    __

mandarin = 4;
dutch = 5;
english = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM - 2 || TRUE

flags ^ error < count

done && started % rate

started | options && error

flags & STATE | DONE

remember would refer back not seen

  plastic =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

verb = 5;
noun = 4;
adjective = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < temp && flag

2 - started && TRUE

0xff | error != temp

flag && error << ERROR

done && bits | 0xff

remember would refer back not seen

  adjective =     ____    __    __

  fence =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

dress = 8;
shirt = 4;
trousers = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | mask << FLAGS

TRUE | rate * 2

temp != rate * num

num << finished < n

2 % error && done

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  string =     ____    __    __

  trousers =     ____    __    __

knife = 5;
hot = 8;
spoon = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && flag ^ finished

done && TRUE & started

started | flag & TRUE

mask | count < n

num << finished & started

remember would refer back not seen

  hot =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

canal = 6;
stream = 9;
tangent = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE || error * offset

7 < n != 7

n < resource << state

flag || TRUE | finished

options ^ error << finished

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  tangent =     ____    __    __

petrol = 5;
plumber = 9;
painter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && val != 7

finished && TRUE & ERROR

TRUE && 2 * length

done && TRUE - count

finished && done < length

remember would refer back not seen

  plumber =     ____    __    __

  petrol =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

hammer = 8;
saddle = 5;
screwdriver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && error << rate

done && TRUE ^ mask

num * RATE && finished

flag && done | options

2 * LENGTH - offset

remember would refer back not seen

  hammer =     ____    __    __

  saddle =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

blue = 6;
red = 4;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && DONE || TRUE

offset * count < VAL

error & field != RESOURCE

offset * done << error

length * count ^ options

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  occult =     ____    __    __

  red =     ____    __    __

wood = 5;
sofa = 9;
chair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT * offset | mask

num * NUM || started

TRUE << count - 2

OFFSET - num != temp

count << resource < length

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

  wood =     ____    __    __

string = 6;
germany = 9;
sweden = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - bits & mask

OPTIONS << mask ^ TRUE

rate - done && finished

done << bits | finished

STARTED << TRUE || started

remember would refer back not seen

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

  string =     ____    __    __

report = 5;
jupiter = 8;
venus = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT < val != n

val < 0xff & FLAG

RESOURCE != field & error

options ^ BITS << mask

field < num && done

remember would refer back not seen

  jupiter =     ____    __    __

  mars =     ____    __    __

  report =     ____    __    __

  venus =     ____    __    __

pencil = 9;
cow = 4;
pig = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource != n && started

TRUE ^ done | 0XFF

resource < val * rate

field != val * offset

0xff ^ error || TRUE

remember would refer back not seen

  pig =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

  pencil =     ____    __    __

bee = 6;
fly = 5;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < count - offset

field != 2 - length

error | resource != 7

7 != temp < count

started | mask & flags

remember would refer back not seen

  fly =     ____    __    __

  wasp =     ____    __    __

  occult =     ____    __    __

  bee =     ____    __    __

blackbird = 9;
pencil = 5;
robin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != temp << length

bits | started && STARTED

resource != done ^ error

mask | started * length

field != bits | options

remember would refer back not seen

  pencil =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

banana = 6;
pear = 9;
lizard = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || finished | done

TRUE | OFFSET - rate

7 != error || flag

options | error < n

FINISHED | flag << TRUE

remember would refer back not seen

  lizard =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

hour = 4;
second = 8;
tangent = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & finished && TRUE

state & OPTIONS * length

error & started - offset

TRUE & MASK < 2

0xff & flag << finished

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  tangent =     ____    __    __

snake = 9;
chestnut = 5;
elm = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & flags ^ TRUE

mask & flags | mask

count - offset * 2

options & state || error

count - COUNT < OFFSET

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  snake =     ____    __    __

october = 4;
grass = 9;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT * resource != FIELD

rate - offset << length

2 % FLAG & started

count - STARTED ^ 0xff

count - offset | finished

remember would refer back not seen

  grass =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

lung = 6;
liver = 9;
kettle = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - count || started

count << done != 7

val < bits << state

0XFF << done & options

2 < num ^ mask

remember would refer back not seen

  lung =     ____    __    __

  heart =     ____    __    __

  kettle =     ____    __    __

  liver =     ____    __    __

scrabble = 8;
solitaire = 9;
poker = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate << started && flag

field < num | done

TRUE << num / length

rate < COUNT || FINISHED

FINISHED ^ error != resource

remember would refer back not seen

  solitaire =     ____    __    __

  plastic =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

mandarin = 4;
propeller = 9;
dutch = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ mask & done

finished ^ mask && started

started | finished ^ started

MASK ^ done * count

started | bits || done

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

  propeller =     ____    __    __

verb = 5;
adjective = 6;
noun = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ 2 - RATE

done || started != resource

mask ^ 0xff < N

done || error & ERROR

STARTED || started && finished

remember would refer back not seen

  adjective =     ____    __    __

  fence =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

shirt = 8;
trousers = 4;
dress = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || offset * count

error || 2 - count

done || n < 7

flag || finished << RATE

finished || started ^ flag

remember would refer back not seen

  trousers =     ____    __    __

  tail =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

spoon = 5;
engine = 6;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && TRUE != n

TRUE && flag & error

error && started * 2

TRUE && rate - 2

flag && count < length

remember would refer back not seen

  engine =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

stream = 9;
canal = 6;
river = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && flag << length

FLAG && 0xff ^ TRUE

offset * TRUE && finished

started && flag | ERROR

count % length - offset

remember would refer back not seen

  canal =     ____    __    __

  plastic =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

petrol = 5;
builder = 9;
plumber = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && TRUE || started

count * rate < temp

mask & val != 7

count / rate << NUM

length % count ^ 0xff

remember would refer back not seen

  builder =     ____    __    __

  petrol =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

saddle = 5;
saw = 4;
screwdriver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate / flags | bits

rate * count || error

TRUE << 2 - count

2 - length != n

finished << field < temp

remember would refer back not seen

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

  saddle =     ____    __    __

red = 6;
blue = 8;
green = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + val != field

0xff << rate ^ bits

num + options ^ flag

flag & 0xff << flag

options & bits || finished

remember would refer back not seen

  red =     ____    __    __

  blue =     ____    __    __

  propeller =     ____    __    __

  green =     ____    __    __

sofa = 4;
snake = 9;
chair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & FINISHED + 2

state | TRUE << finished

length < TEMP != resource

OFFSET * rate & error

length < val * rate

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  snake =     ____    __    __

  table =     ____    __    __

germany = 5;
sweden = 4;
plastic = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE | error + num

2 < OFFSET & options

flags ^ count * offset

2 < finished ^ 0xff

val != error ^ BITS

remember would refer back not seen

  plastic =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

venus = 4;
jupiter = 6;
mars = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && 0xff ^ state

TRUE | state & TRUE

state << TRUE && finished

0XFF ^ temp < val

bits ^ field != 7

remember would refer back not seen

  fence =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

sheep = 8;
pig = 5;
cow = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * n < 2

2 + RATE & options

error || started ^ OPTIONS

num * flag && error

7 != done | flag

remember would refer back not seen

  sheep =     ____    __    __

  hair =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

wasp = 5;
bee = 6;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags | started && finished

offset + done || TRUE

n != rate < offset

error ^ TRUE && flag

rate % 2 | mask

remember would refer back not seen

  bee =     ____    __    __

  occult =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

blackbird = 8;
robin = 6;
sparrow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state | finished || error

flag | state * rate

temp != field * count

done && offset < val

finished || length + count

remember would refer back not seen

  saddle =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

banana = 8;
apple = 6;
pear = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < count && error

state << bits & ERROR

rate << state != FIELD

STARTED || done << flag

length < offset << FLAG

remember would refer back not seen

  exterior =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

minute = 4;
wax = 6;
hour = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & 0xff | state

started ^ mask | FLAG

FINISHED | TRUE ^ bits

7 != mask << error

options & 7 < val

remember would refer back not seen

  wax =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

oak = 9;
hot = 6;
chestnut = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || TRUE && error

val != 0XFF & STATE

state & finished && DONE

length * 7 != temp

error & n != val

remember would refer back not seen

  hot =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

october = 9;
june = 5;
january = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state | resource != field

TRUE || finished | flag

mask & error ^ flags

val != 2 + offset

flag << offset || flag

remember would refer back not seen

  october =     ____    __    __

  january =     ____    __    __

  room =     ____    __    __

  june =     ____    __    __

lung = 8;
heart = 4;
liver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != temp && TRUE

num * rate << FINISHED

state ^ started << options

error && 2 + rate

7 != finished || started

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

  lizard =     ____    __    __

solitaire = 6;
tangent = 5;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM << 0XFF | finished

TRUE || 2 * count

count + offset < 2

TRUE && N != VAL

started | bits < 7

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  tangent =     ____    __    __

  solitaire =     ____    __    __

mandarin = 5;
english = 4;
wheel = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + 2 | 0xff

offset % rate + length

TRUE ^ bits & finished

val < offset + 2

started && BITS << 2

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  wheel =     ____    __    __

verb = 9;
noun = 6;
adjective = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET << rate * 2

done & bits % COUNT

finished ^ count + 2

7 < started | flag

finished && done | bits

remember would refer back not seen

  string =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

tail = 5;
trousers = 6;
dress = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || error < offset

finished ^ started || done

started && ERROR & bits

2 + num << done

bits << count < 7

remember would refer back not seen

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

  tail =     ____    __    __

report = 5;
fork = 6;
spoon = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags << rate + offset

TRUE && flag * 2

error && TRUE || finished

FLAG || TRUE != 7

count + offset * OFFSET

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  report =     ____    __    __

stream = 6;
kettle = 9;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < flag || started

started || done & error

rate + error && flag

length * 2 || FLAG

length * options ^ 0xff

remember would refer back not seen

  canal =     ____    __    __

  kettle =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

plumber = 9;
painter = 5;
propeller = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && error != field

error && finished & flags

done && count * length

TRUE && finished + length

finished && TRUE < count

remember would refer back not seen

  propeller =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

hammer = 6;
screwdriver = 8;
saw = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && flag << length

FINISHED && done ^ finished

COUNT * finished && flag

flag && mask | flag

2 / rate + count

remember would refer back not seen

  plastic =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

green = 6;
red = 5;
saddle = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && ERROR || TRUE

num * rate < n

flag & error != field

num * error << length

count * rate ^ mask

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  saddle =     ____    __    __

  red =     ____    __    __

wood = 5;
sofa = 9;
table = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * error | TRUE

rate * count || TRUE

state << finished + num

rate + temp != N

options << 2 < length

remember would refer back not seen

  chair =     ____    __    __

  wood =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

tangent = 5;
germany = 6;
sweden = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + RATE & options

flag << TRUE ^ state

length + TRUE && error

flags << done | error

RATE << done || started

remember would refer back not seen

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

  tangent =     ____    __    __

jupiter = 8;
mars = 6;
venus = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < num != val

2 < num & mask

resource != mask & flags

finished ^ num << rate

resource < started && finished

remember would refer back not seen

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

  pencil =     ____    __    __

sheep = 5;
pig = 6;
cow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 != done && TRUE

finished ^ 0xff | MASK

num < count * 2

field != val * 2

flags ^ finished || done

remember would refer back not seen

  pig =     ____    __    __

  cow =     ____    __    __

  petrol =     ____    __    __

  sheep =     ____    __    __

bee = 9;
hot = 5;
fly = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

VAL < num + rate

temp != n + length

state | n != FIELD

TEMP != 7 < val

flags | state & error

remember would refer back not seen

  wasp =     ____    __    __

  bee =     ____    __    __

  hot =     ____    __    __

  fly =     ____    __    __

blackbird = 5;
exterior = 8;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != num << 0xff

TRUE | BITS && finished

n != resource ^ options

DONE | COUNT * num

field != started | done

remember would refer back not seen

  robin =     ____    __    __

  exterior =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

pear = 5;
banana = 9;
atom = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || bits | flag

finished | error + count

FIELD != n || TRUE

bits | field < val

finished | flag << num

remember would refer back not seen

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

  atom =     ____    __    __

plastic = 8;
second = 5;
hour = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & DONE && error

error & length * offset

flags & STATE + offset

started & bits < RATE

error & count << started

remember would refer back not seen

  plastic =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

oak = 9;
chestnut = 8;
elm = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & 0xff ^ flag

mask & done | state

2 + OFFSET % num

flag & started || done

rate + count < n

remember would refer back not seen

  chestnut =     ____    __    __

  wax =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

june = 4;
october = 6;
comb = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * 2 != temp

num + RATE << length

offset * length & error

count + flags ^ done

offset + STATE | done

remember would refer back not seen

  june =     ____    __    __

  comb =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

chapter = 5;
liver = 8;
lung = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + started || flag

done << n != N

n < offset << mask

2 << state & finished

field < TRUE ^ flags

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

  chapter =     ____    __    __

kettle = 9;
poker = 8;
scrabble = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask << state && TRUE

2 < error | bits

options << 0xff * OFFSET

n < field || started

done ^ temp != val

remember would refer back not seen

  solitaire =     ____    __    __

  kettle =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

dutch = 5;
english = 9;
mandarin = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG ^ FINISHED & finished

options ^ flags && flag

TRUE | 0xff ^ finished

error ^ done * num

finished | flag || started

remember would refer back not seen

  mandarin =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

  engine =     ____    __    __

fence = 6;
adjective = 9;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ offset + num

finished || resource != temp

finished ^ 7 < 2

TRUE || flags & state

done || ERROR && done

remember would refer back not seen

  verb =     ____    __    __

  adjective =     ____    __    __

  fence =     ____    __    __

  noun =     ____    __    __

shirt = 6;
dress = 8;
trousers = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || done * num

finished || length + count

finished || done < TEMP

finished || done << num

done || bits ^ options

remember would refer back not seen

  dress =     ____    __    __

  report =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

string = 4;
spoon = 8;
fork = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && val != resource

STARTED && done & started

FINISHED && done * LENGTH

started && rate + 2

FINISHED && N < n

remember would refer back not seen

  knife =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

  string =     ____    __    __

stream = 5;
canal = 9;
tail = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && done << flag

TRUE && started ^ finished

num * TRUE && ERROR

done && flag | state

num / 2 + rate

remember would refer back not seen

  stream =     ____    __    __

  tail =     ____    __    __

  canal =     ____    __    __

  river =     ____    __    __

builder = 5;
propeller = 6;
plumber = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && started || TRUE

LENGTH * length < num

done & resource != n

num * STATE << 2

offset * 2 ^ done

remember would refer back not seen

  plumber =     ____    __    __

  propeller =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

plastic = 4;
hammer = 8;
screwdriver = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate / started | mask

offset % count || TRUE

count << num + count

rate + field != n

error << STARTED < 7

remember would refer back not seen

  screwdriver =     ____    __    __

  plastic =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

green = 9;
red = 5;
blue = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & num * rate

options << started * offset

NUM << error || flag

RATE - rate < n

n == mask ^ started

remember would refer back not seen

  blue =     ____    __    __

  grass =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

table = 5;
tangent = 9;
chair = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < COUNT * LENGTH

flag && done | started

finished & TRUE || done

RESOURCE < num && finished

TEMP < 2 << rate

remember would refer back not seen

  sofa =     ____    __    __

  tangent =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

sweden = 4;
germany = 5;
wood = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * num - count

length % flag && error

2 < 0xff | mask

TEMP == flags | error

error | flag || TRUE

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  wood =     ____    __    __

jupiter = 6;
wax = 9;
venus = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask ^ done && flag

n == val < count

2 << finished & flags

flag ^ error || ERROR

started || count - rate

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  wax =     ____    __    __

pig = 5;
cow = 8;
pencil = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || finished < num

rate * mask ^ options

length << started < resource

offset % error || flag

state << FINISHED | TRUE

remember would refer back not seen

  pencil =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

wasp = 8;
plastic = 4;
bee = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RESOURCE == field || done

started && TRUE || STARTED

state << length && error

finished && done << TRUE

offset < flag || done

remember would refer back not seen

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

  plastic =     ____    __    __

sparrow = 9;
blackbird = 5;
robin = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & temp == 7

mask | options == 7

TRUE || done == n

flag ^ num - rate

2 - offset || finished

remember would refer back not seen

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  room =     ____    __    __

pear = 9;
atom = 5;
banana = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < count - rate

flag & state ^ finished

done | options & 0xff

flags | started << rate

NUM - length | STARTED

remember would refer back not seen

  apple =     ____    __    __

  atom =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

report = 9;
second = 6;
hour = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ finished == field

done || FLAG & TRUE

num * length < 2

2 * state | flags

val == offset - NUM

remember would refer back not seen

  report =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

chestnut = 6;
oak = 9;
elm = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & flags - offset

offset << NUM - rate

STARTED ^ bits | error

count - flag & flags

rate - length * offset

remember would refer back not seen

  elm =     ____    __    __

  oak =     ____    __    __

  kettle =     ____    __    __

  chestnut =     ____    __    __

june = 8;
hair = 4;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ 0xff << mask

rate - finished ^ FLAG

TRUE & options | error

done && TRUE ^ done

offset * 2 & TRUE

remember would refer back not seen

  june =     ____    __    __

  hair =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

liver = 6;
heart = 5;
lung = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < field ^ options

done && finished - COUNT

0xff << N == val

n == resource * count

done || flag << finished

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  tail =     ____    __    __

  heart =     ____    __    __

poker = 9;
scrabble = 6;
fence = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ options & mask

temp == n && flag

count - offset && flag

temp == 7 & finished

2 - count << length

remember would refer back not seen

  fence =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

english = 8;
dutch = 4;
mandarin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < 7 == field

FLAG && done % num

OFFSET * rate << OPTIONS

0xff ^ length < count

num - N == field

remember would refer back not seen

  string =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

noun = 6;
adjective = 5;
exterior = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE || state | STATE

OPTIONS | bits - length

error || started ^ mask

state & options << mask

n == error << done

remember would refer back not seen

  adjective =     ____    __    __

  exterior =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

dress = 4;
trousers = 5;
saddle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE && started < 2

started ^ count / rate

offset << num ^ flag

TRUE && flag == 7

0xff | 2 < rate

remember would refer back not seen

  saddle =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

spoon = 9;
knife = 4;
comb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && state & done

val < count & error

started & error && flag

TRUE | bits * length

done | finished && TRUE

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  comb =     ____    __    __

  spoon =     ____    __    __

river = 6;
membrane = 4;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & options < resource

TRUE || finished && TRUE

offset / count == 7

started || TRUE * rate

flags | bits ^ 0xff

remember would refer back not seen

  river =     ____    __    __

  membrane =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

propeller = 9;
plumber = 8;
builder = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & TRUE && done

options & rate % offset

mask & count - LENGTH

flags & field < rate

options & bits << rate

remember would refer back not seen

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  propeller =     ____    __    __

screwdriver = 4;
hammer = 8;
snake = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & resource == 7

bits & mask ^ bits

rate - length * rate

mask & started | flags

num - count < TEMP

remember would refer back not seen

  snake =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

green = 6;
blue = 4;
lizard = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & DONE || flag

count - offset << 0XFF

offset * COUNT & TRUE

count - COUNT == VAL

offset - OFFSET ^ bits

remember would refer back not seen

  red =     ____    __    __

  green =     ____    __    __

  lizard =     ____    __    __

  blue =     ____    __    __

chair = 4;
saddle = 5;
sofa = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - mask | done

2 - count || error

field < started << bits

NUM << finished & 0XFF

RATE < resource == field

remember would refer back not seen

  table =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

  saddle =     ____    __    __

sweden = 9;
room = 4;
france = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options << started && flag

rate < length ^ state

TRUE << num / count

RESOURCE < FLAGS | finished

field < started || ERROR

remember would refer back not seen

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

  room =     ____    __    __

wax = 8;
venus = 6;
mars = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == resource & 0xff

resource == TEMP && error

finished && 0xff & mask

TRUE ^ n == 7

FIELD == 2 * rate

remember would refer back not seen

  mars =     ____    __    __

  venus =     ____    __    __

  wax =     ____    __    __

  jupiter =     ____    __    __

sheep = 9;
cow = 6;
pig = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && length % rate

mask ^ flags | TRUE

FIELD == rate - count

flag && TRUE - num

state ^ started || flag

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  wheel =     ____    __    __

  sheep =     ____    __    __

bee = 6;
wasp = 9;
membrane = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TEMP == offset < N

started && done < 7

options | done & error

flag && TRUE << offset

flags | error && finished

remember would refer back not seen

  wasp =     ____    __    __

  membrane =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

robin = 9;
report = 5;
blackbird = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && field == n

finished | num * RATE

finished && done ^ TRUE

mask | error - rate

started && error | ERROR

remember would refer back not seen

  report =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

pear = 6;
pencil = 4;
apple = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || done | mask

bits | resource < 7

TRUE && started || done

flag | state << started

mask | flags == RESOURCE

remember would refer back not seen

  apple =     ____    __    __

  pencil =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

minute = 5;
hour = 6;
second = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * error && finished

count * 2 - count

offset * num < offset

count % length << bits

2 * val == field

remember would refer back not seen

  tangent =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

oak = 4;
chestnut = 8;
elm = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * state ^ finished

num * state | 0xff

state << count - length

OFFSET * done || finished

count << started < N

remember would refer back not seen

  oak =     ____    __    __

  exterior =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

june = 4;
fence = 8;
october = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - num & started

options << n == temp

2 - num && flag

state << FLAG ^ done

flags << flag | finished

remember would refer back not seen

  january =     ____    __    __

  fence =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

heart = 5;
grass = 9;
liver = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << count || error

field < started & state

7 == flag << 0xff

count < FLAG && TRUE

7 == mask ^ flag

remember would refer back not seen

  liver =     ____    __    __

  heart =     ____    __    __

  grass =     ____    __    __

  lung =     ____    __    __

comb = 6;
solitaire = 5;
poker = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < rate % num

n == state | options

NUM < 2 - length

resource == n || done

error ^ mask & options

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  comb =     ____    __    __

english = 9;
plastic = 8;
mandarin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits ^ error && TRUE

state ^ rate * 2

OPTIONS | DONE ^ mask

state ^ 2 - rate

0xff | flag || done

remember would refer back not seen

  english =     ____    __    __

  plastic =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

noun = 8;
verb = 4;
chapter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ TRUE < length

FLAG || DONE & mask

mask ^ flag << error

done || error && done

started || flag / 2

remember would refer back not seen

  noun =     ____    __    __

  chapter =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

trousers = 8;
shirt = 6;
string = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || TRUE - offset

done || n < 2

flag || finished << state

done || error == n

error || state ^ TRUE

remember would refer back not seen

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

  string =     ____    __    __

hair = 4;
spoon = 9;
knife = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & started && done

0xff & finished * COUNT

options & 0xff - num

flags & rate < offset

flags & finished << rate

remember would refer back not seen

  fork =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

  hair =     ____    __    __

river = 6;
occult = 9;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS & finished == field

TRUE & options ^ flags

length - COUNT / rate

state & done | error

count - rate < num

remember would refer back not seen

  river =     ____    __    __

  occult =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

builder = 6;
painter = 9;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

BITS & finished || flag

count - length << state

COUNT * rate & finished

length - offset == N

offset - count ^ state

remember would refer back not seen

  painter =     ____    __    __

  builder =     ____    __    __

  propeller =     ____    __    __

  plumber =     ____    __    __

snake = 5;
hammer = 4;
screwdriver = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count - 2 | options

rate - 2 || STARTED

field < done << state

num << count & bits

resource < n == FIELD

remember would refer back not seen

  snake =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

blue = 4;
wax = 5;
green = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & 2 << length

temp == error && done

offset + 2 && error

flag & started ^ flag

started << 0xff ^ mask

remember would refer back not seen

  wax =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

table = 4;
chair = 6;
sofa = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags << num + 2

done && finished ^ TRUE

error << finished || error

flags & RATE * 2

val < done || error

remember would refer back not seen

  sofa =     ____    __    __

  chair =     ____    __    __

  comb =     ____    __    __

  table =     ____    __    __

germany = 8;
sweden = 9;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * flag && finished

RATE << state & mask

flag && length + offset

offset / COUNT << error

TRUE | state && TRUE

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  kettle =     ____    __    __

  germany =     ____    __    __

jupiter = 9;
venus = 8;
grass = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || started << count

num + rate == n

2 < state & done

2 + count ^ mask

flag && options & flags

remember would refer back not seen

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

  grass =     ____    __    __

sheep = 5;
pig = 4;
propeller = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < val ^ flag

rate * 2 < FIELD

length % rate & mask

finished & started == n

flag && finished / rate

remember would refer back not seen

  propeller =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

wasp = 6;
bee = 4;
pencil = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + length < count

TRUE || flag % 2

offset / n == 7

state ^ error * offset

2 < n && done

remember would refer back not seen

  bee =     ____    __    __

  wasp =     ____    __    __

  pencil =     ____    __    __

  fly =     ____    __    __

robin = 6;
sparrow = 9;
atom = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == RESOURCE << flag

DONE & started && TRUE

flag ^ 0xff | done

options ^ done + RATE

started & 2 < LENGTH

remember would refer back not seen

  atom =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

pear = 8;
apple = 4;
banana = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || finished && done

7 == STARTED ^ done

2 * num + offset

rate << mask * offset

error & options | error

remember would refer back not seen

  tail =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

pencil = 8;
second = 9;
minute = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ error && DONE

rate * flag || finished

TRUE || n == field

length * count | started

flags ^ finished < 7

remember would refer back not seen

  hour =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  pencil =     ____    __    __

elm = 8;
oak = 4;
chestnut = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < offset + rate

val == temp & flag

started ^ done & error

DONE || done | 0xff

2 + length * 2

remember would refer back not seen

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

  chapter =     ____    __    __

october = 4;
occult = 5;
january = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag << error && started

length < count == val

num << val == 7

FLAGS | state << error

temp == N < offset

remember would refer back not seen

  june =     ____    __    __

  october =     ____    __    __

  occult =     ____    __    __

  january =     ____    __    __

lung = 6;
liver = 5;
heart = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && flags << mask

error || finished + length

length + num & flags

FLAGS & started || flag

0xff | finished ^ started

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

  wheel =     ____    __    __

poker = 5;
plastic = 9;
solitaire = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate % num ^ done

flag ^ state << offset

options | 7 == VAL

done || 0XFF ^ error

error || flag & error

remember would refer back not seen

  plastic =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

wood = 9;
english = 6;
dutch = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + offset | done

started && 7 < n

ERROR | count + length

done && finished | mask

STATE ^ started || error

remember would refer back not seen

  wood =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

noun = 6;
string = 4;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < num << options

temp == n || error

TRUE && temp == n

done << field < count

options | error & flags

remember would refer back not seen

  noun =     ____    __    __

  string =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

trousers = 5;
saddle = 9;
shirt = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate < count * num

flag | OFFSET < TEMP

length + offset << started

flags & rate + count

length + num || finished

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  saddle =     ____    __    __

membrane = 8;
knife = 5;
fork = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ n == 7

val < flag | started

n == 2 * length

DONE | options || flag

flag && TRUE || flag

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  membrane =     ____    __    __

  spoon =     ____    __    __

stream = 6;
river = 4;
report = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << error | flags

flag | finished * count

STARTED || TRUE < val

field == options | started

field == 2 + offset

remember would refer back not seen

  river =     ____    __    __

  canal =     ____    __    __

  report =     ____    __    __

  stream =     ____    __    __

painter = 5;
builder = 8;
plumber = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STARTED & mask && started

state & TRUE * COUNT

TRUE & 0xff + count

flags & mask < 2

options & TRUE << rate

remember would refer back not seen

  painter =     ____    __    __

  atom =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

hammer = 6;
screwdriver = 5;
lizard = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & flags == temp

options & mask ^ flags

rate + offset % rate

bits & state | finished

num + rate < temp

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  lizard =     ____    __    __

  saw =     ____    __    __

blue = 6;
tangent = 5;
green = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & ERROR || finished

rate + count << 2

count / offset & error

offset + VAL == resource

2 + num ^ started

remember would refer back not seen

  blue =     ____    __    __

  red =     ____    __    __

  tangent =     ____    __    __

  green =     ____    __    __

chair = 9;
pencil = 4;
sofa = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + length | done

length + TRUE || done

num < started << options

flag << done & error

resource < offset == TEMP

remember would refer back not seen

  table =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

  pencil =     ____    __    __

sweden = 4;
germany = 6;
room = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << finished && error

num < offset ^ state

started << count * 2

2 < started | mask

TEMP < finished || started

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  room =     ____    __    __

venus = 9;
wheel = 5;
jupiter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == started & flags

7 == flag && finished

started && state & bits

done ^ flag == 7

n == offset * RATE

remember would refer back not seen

  mars =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  wheel =     ____    __    __

propeller = 4;
sheep = 8;
cow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && length * 2

mask ^ STATE | options

field == 2 + count

done && FLAG + count

error ^ done || error

remember would refer back not seen

  sheep =     ____    __    __

  pig =     ____    __    __

  propeller =     ____    __    __

  cow =     ____    __    __

string = 6;
bee = 4;
wasp = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == val < rate

error && TRUE < 7

TRUE | mask & bits

TRUE && flag << started

0XFF | finished && done

remember would refer back not seen

  bee =     ____    __    __

  fly =     ____    __    __

  string =     ____    __    __

  wasp =     ____    __    __

blackbird = 6;
robin = 4;
plastic = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && val == field

started | 0XFF * 2

done && state ^ options

TRUE | length + 2

finished && started | bits

remember would refer back not seen

  robin =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  plastic =     ____    __    __

banana = 8;
fence = 4;
pear = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || TRUE | flags

flag | num < length

done && finished || done

0xff | options << length

bits | options == resource

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

  fence =     ____    __    __

hour = 5;
occult = 8;
minute = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * error && started

count * length + rate

count * 2 < val

num * options << TRUE

count * rate == val

remember would refer back not seen

  second =     ____    __    __

  occult =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

oak = 4;
chestnut = 6;
elm = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * COUNT ^ started

offset * length | bits

count << 2 + num

2 * offset || error

MASK << length < temp

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  petrol =     ____    __    __

october = 8;
june = 5;
tail = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + length & done

offset << error == val

count + done && started

0xff << flags ^ mask

length << options | mask

remember would refer back not seen

  june =     ____    __    __

  tail =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

heart = 6;
lung = 5;
grass = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << 2 || error

offset < TRUE & FINISHED

val == options << num

length < done && TRUE

val == 0xff ^ options

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

  grass =     ____    __    __

poker = 8;
scrabble = 4;
solitaire = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

VAL < rate % COUNT

resource == temp | flags

7 < LENGTH + OFFSET

VAL == finished || TRUE

0xff ^ bits & error

remember would refer back not seen

  scrabble =     ____    __    __

  occult =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

hair = 9;
mandarin = 8;
dutch = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK ^ done && error

mask ^ started * 2

finished | options ^ state

flag ^ RATE + num

bits | options || TRUE

remember would refer back not seen

  hair =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

adjective = 6;
chapter = 9;
noun = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ flag < length

done || flag & flags

options ^ TRUE << length

flag || error && flag

started || TRUE * count

remember would refer back not seen

  adjective =     ____    __    __

  verb =     ____    __    __

  chapter =     ____    __    __

  noun =     ____    __    __

plastic = 8;
shirt = 4;
dress = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || 2 + num

error || LENGTH < length

TRUE || MASK << 2

started || finished == n

error || flag ^ options

remember would refer back not seen

  shirt =     ____    __    __

  plastic =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

fork = 5;
knife = 4;
hot = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAGS & error && TRUE

error & count % num

options & done + length

FLAGS & 0xff < 7

options & bits << started

remember would refer back not seen

  hot =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

stream = 5;
river = 6;
pencil = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & flag == field

options & flags ^ finished

LENGTH + length % count

mask & options | flag

length + 2 < n

remember would refer back not seen

  pencil =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

atom = 9;
painter = 4;
plumber = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & error || TRUE

rate + length << done

LENGTH * length & done

count + resource == field

rate + offset ^ done

remember would refer back not seen

  plumber =     ____    __    __

  atom =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

saw = 5;
screwdriver = 6;
hammer = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + bits | options

count + flag || started

7 < offset << done

num << started & bits

val < field == temp

remember would refer back not seen

  saw =     ____    __    __

  lizard =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

blue = 8;
red = 6;
green = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != resource * count

bits | flags && flag

error || done && started

rate * length < offset

options << error || flag

remember would refer back not seen

  blue =     ____    __    __

  report =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

sofa = 8;
chair = 9;
table = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && 2 < count

finished && flag || finished

length < 0xff << flags

2 - length * count

started | 7 != N

remember would refer back not seen

  chair =     ____    __    __

  tangent =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

france = 9;
plastic = 8;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ 0xff && finished

2 * offset & 0xff

length - rate ^ OPTIONS

options | DONE < 2

FIELD < 0xff ^ bits

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

  plastic =     ____    __    __

mars = 6;
venus = 8;
jupiter = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || n != val

finished & TRUE && started

num - state << 0xff

mask | flag - length

0xff ^ error < resource

remember would refer back not seen

  plastic =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

sheep = 5;
cow = 4;
comb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ rate * offset

TRUE && finished & TRUE

done || TRUE | error

state ^ mask << bits

COUNT - started && finished

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  comb =     ____    __    __

bee = 8;
wasp = 5;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * offset - NUM

num - rate < val

STATE & 2 * offset

error & mask - num

flag & options | flags

remember would refer back not seen

  occult =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

robin = 6;
wheel = 4;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & bits || finished

val != started | finished

error | bits ^ flags

COUNT << num & 0xff

error ^ n != temp

remember would refer back not seen

  wheel =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

petrol = 9;
banana = 6;
pear = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < temp && finished

bits << state | FLAGS

count * length ^ finished

TRUE && offset - num

TRUE & state != temp

remember would refer back not seen

  pear =     ____    __    __

  banana =     ____    __    __

  petrol =     ____    __    __

  apple =     ____    __    __

grass = 8;
second = 4;
minute = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || rate * length

7 < error || flag

state << started != n

error && OFFSET * rate

options << finished && FLAG

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  grass =     ____    __    __

  hour =     ____    __    __

elm = 9;
oak = 5;
chestnut = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * offset != field

resource != RESOURCE & finished

resource != 7 && finished

7 < 2 & options

options ^ num - RATE

remember would refer back not seen

  elm =     ____    __    __

  string =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

occult = 5;
october = 6;
june = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << length - count

temp != resource || FINISHED

done | offset << flags

offset % started && TRUE

options & finished << offset

remember would refer back not seen

  january =     ____    __    __

  occult =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

heart = 9;
liver = 4;
hot = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished | error || flag

done << length < 2

length < val != temp

done ^ DONE | finished

length - rate & error

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  hot =     ____    __    __

  lung =     ____    __    __

scrabble = 4;
propeller = 8;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != 7 << bits

flag && error ^ 0xff

count - length | started

val < count / rate

FIELD < mask | flags

remember would refer back not seen

  poker =     ____    __    __

  solitaire =     ____    __    __

  propeller =     ____    __    __

  scrabble =     ____    __    __

tail = 5;
mandarin = 4;
english = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * 2 | 0xff

rate - count != temp

resource != VAL < temp

ERROR | FLAG & options

num << bits ^ STARTED

remember would refer back not seen

  tail =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

verb = 6;
fence = 8;
adjective = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != 7 - NUM

error || TRUE & bits

flag && TRUE != resource

started || error << num

LENGTH * finished || done

remember would refer back not seen

  fence =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

shirt = 4;
trousers = 9;
snake = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - length || done

started || 0xff ^ started

started && BITS << 2

finished ^ mask || DONE

rate < resource - num

remember would refer back not seen

  dress =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

  snake =     ____    __    __

lizard = 5;
spoon = 8;
fork = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & done < resource

flag || rate - count

started ^ finished & done

flags | 0xff * offset

FINISHED && done | mask

remember would refer back not seen

  lizard =     ____    __    __

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

stream = 6;
canal = 8;
river = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || TRUE < NUM

bits << length % 2

length * LENGTH << options

error & done ^ error

n != 7 ^ started

remember would refer back not seen

  river =     ____    __    __

  canal =     ____    __    __

  saddle =     ____    __    __

  stream =     ____    __    __

painter = 6;
plumber = 5;
wax = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && field != n

started && TRUE & 0xff

started && TRUE * rate

started && rate - 2

TRUE && FLAG < rate

remember would refer back not seen

  wax =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

wheel = 4;
screwdriver = 8;
hammer = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && count << flags

finished && FINISHED ^ MASK

length / count && flag

finished && flag | flags

COUNT % offset - NUM

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  wheel =     ____    __    __

  saw =     ____    __    __

blue = 4;
green = 8;
red = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && finished || TRUE

offset % VAL < resource

flag & error != temp

length * 2 << length

rate * started ^ flag

remember would refer back not seen

  red =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  grass =     ____    __    __

snake = 9;
table = 4;
chair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * offset | mask

RATE * length || ERROR

rate << flag - RATE

count - num != val

options << rate < field

remember would refer back not seen

  table =     ____    __    __

  snake =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

france = 9;
report = 6;
germany = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - 2 & FINISHED

options << flags ^ mask

num - rate && TRUE

bits << ERROR | started

bits << TRUE || FLAG

remember would refer back not seen

  report =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

mars = 5;
plastic = 6;
venus = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < 7 != FIELD

2 < length & error

field != temp & state

state ^ DONE << 0xff

resource < num && finished

remember would refer back not seen

  plastic =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

sheep = 4;
pig = 5;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != resource && error

finished ^ error | finished

val < temp / num

n != 2 * offset

done ^ FLAG || ERROR

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  occult =     ____    __    __

fly = 4;
bee = 9;
wasp = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < rate - OFFSET

n != temp - rate

STARTED | resource != val

temp != rate < count

flag | state & flags

remember would refer back not seen

  bee =     ____    __    __

  fence =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

blackbird = 8;
kettle = 9;
robin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != n << num

bits | finished && flag

field != resource ^ started

flag | length * rate

n != val | ERROR

remember would refer back not seen

  sparrow =     ____    __    __

  kettle =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

pear = 6;
banana = 9;
pencil = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || options | started

flags | state - count

7 != n || TRUE

flags | state < count

mask | flag << offset

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

  pencil =     ____    __    __

comb = 8;
hour = 5;
minute = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & finished && done

finished & TRUE * num

started & MASK - 2

done & 7 < temp

started & rate << flags

remember would refer back not seen

  minute =     ____    __    __

  comb =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

chestnut = 4;
occult = 8;
elm = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & state ^ MASK

started & mask | done

rate - offset * count

mask & finished || flag

length - count < field

remember would refer back not seen

  elm =     ____    __    __

  occult =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

june = 6;
october = 5;
january = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * 2 != val

NUM - done << OFFSET

count % TRUE & bits

offset - flag ^ error

offset - 0xff | done

remember would refer back not seen

  string =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

lung = 5;
hair = 8;
liver = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET - rate || started

state << resource != field

length < num << state

count << 0xff & finished

count < val ^ options

remember would refer back not seen

  lung =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

  hair =     ____    __    __

wood = 8;
poker = 5;
solitaire = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RATE << TRUE && started

2 < started | FLAGS

flags << length / num

rate < val || error

done ^ resource != field

remember would refer back not seen

  wood =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

english = 9;
dutch = 8;
chapter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ error & mask

error ^ 0XFF && error

finished | done ^ bits

flag ^ options * offset

started | TRUE || started

remember would refer back not seen

  dutch =     ____    __    __

  chapter =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

noun = 9;
tangent = 4;
adjective = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ LENGTH - offset

finished || flag != field

0xff ^ field < resource

error || STARTED & mask

started || flag && finished

remember would refer back not seen

  verb =     ____    __    __

  tangent =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

membrane = 5;
shirt = 4;
dress = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || finished / count

error || FINISHED - NUM

done || temp < val

FLAG || error << state

TRUE || flag ^ done

remember would refer back not seen

  trousers =     ____    __    __

  membrane =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

knife = 6;
spoon = 5;
fork = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && resource != temp

flag && finished & error

finished && 2 * offset

TRUE && rate - 2

started && FLAG < offset

remember would refer back not seen

  spoon =     ____    __    __

  knife =     ____    __    __

  pencil =     ____    __    __

  fork =     ____    __    __

canal = 9;
stream = 5;
river = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE && flag << started

done && error ^ flag

length * num && started

flag && TRUE | finished

num * offset - count

remember would refer back not seen

  room =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

plumber = 8;
wax = 4;
painter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && error || TRUE

offset * VAL < resource

started & bits != resource

2 * done << 0xff

rate * offset ^ flag

remember would refer back not seen

  wax =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

wheel = 6;
screwdriver = 8;
hammer = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * done | state

offset * rate || flag

error << count - offset

num - val != FIELD

bits << STARTED < count

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  wheel =     ____    __    __

  saw =     ____    __    __

red = 6;
green = 9;
occult = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished << rate ^ finished

options ^ num + rate

val < 0xff & error

state & MASK < val

started & state | 0xff

remember would refer back not seen

  blue =     ____    __    __

  occult =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

exterior = 4;
sofa = 9;
table = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || num + length

count << 2 * offset

LENGTH < temp && ERROR

2 * TRUE || flag

done ^ num * count

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

  exterior =     ____    __    __

wheel = 5;
france = 6;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && finished | flag

finished && TRUE << finished

2 < 7 != n

done && flags ^ TRUE

0xff & options ^ FLAG

remember would refer back not seen

  wheel =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

jupiter = 8;
pencil = 6;
venus = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS & 0xff + length

flags ^ mask < temp

num * done && started

error || 0xff << started

LENGTH * count & state

remember would refer back not seen

  jupiter =     ____    __    __

  pencil =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

pig = 8;
tangent = 4;
cow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && n < temp

error << mask | TRUE

bits | TRUE ^ 0xff

options & resource != RESOURCE

n != 7 < length

remember would refer back not seen

  pig =     ____    __    __

  sheep =     ____    __    __

  tangent =     ____    __    __

  cow =     ____    __    __

tail = 6;
fly = 5;
wasp = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

BITS << 7 != n

count < temp + offset

length << 2 < offset

TRUE | LENGTH + 2

offset + num & bits

remember would refer back not seen

  fly =     ____    __    __

  tail =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

robin = 8;
blackbird = 4;
plastic = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options | error || done

length << bits && flag

flag || FLAG && TRUE

temp != field | started

count * offset + 2

remember would refer back not seen

  plastic =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

comb = 4;
pear = 6;
apple = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num % offset != val

offset * started << options

TRUE && error & finished

FLAG || finished != n

bits ^ options | finished

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

  comb =     ____    __    __

second = 6;
engine = 9;
hour = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < finished | bits

FLAG | bits && flag

offset + 2 && FINISHED

temp != TRUE || error

BITS ^ flags & state

remember would refer back not seen

  hour =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  engine =     ____    __    __

elm = 5;
oak = 4;
string = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished << flag & state

num + length << TRUE

TRUE || finished | done

TRUE && flag != 7

flag | 7 < length

remember would refer back not seen

  string =     ____    __    __

  oak =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

occult = 6;
october = 9;
january = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & TRUE || flag

FLAG | bits << mask

bits | options & flags

count + STARTED | bits

error || offset * count

remember would refer back not seen

  october =     ____    __    __

  occult =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

lung = 9;
liver = 8;
wood = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | error * count

temp != 2 + num

val != field && finished

error ^ length << num

TRUE || done < temp

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

  wood =     ____    __    __

scrabble = 4;
solitaire = 8;
grass = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < bits << started

flags & mask && finished

error && flag + COUNT

temp < 2 * count

error && num / rate

remember would refer back not seen

  scrabble =     ____    __    __

  poker =     ____    __    __

  grass =     ____    __    __

  solitaire =     ____    __    __

snake = 4;
english = 5;
mandarin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count / offset < n

FINISHED && done || started

NUM * 2 ^ options

error ^ done && TRUE

offset < started || TRUE

remember would refer back not seen

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  snake =     ____    __    __

kettle = 5;
verb = 4;
adjective = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & STARTED << count

count + rate || done

7 != rate * length

rate + field != val

rate + n < 2

remember would refer back not seen

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  kettle =     ____    __    __

shirt = 6;
dress = 9;
hot = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + offset ^ mask

flag << 2 + offset

num + length % rate

finished ^ TRUE || flag

error ^ val != resource

remember would refer back not seen

  hot =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

fork = 5;
knife = 8;
plastic = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | flags != field

2 * offset | started

flags << started || done

done || finished & flags

num < n ^ STATE

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  plastic =     ____    __    __

  spoon =     ____    __    __

stream = 6;
river = 9;
room = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & finished / NUM

field != OPTIONS ^ flag

DONE || flag ^ finished

VAL != resource << done

field != temp & state

remember would refer back not seen

  river =     ____    __    __

  stream =     ____    __    __

  room =     ____    __    __

  canal =     ____    __    __

painter = 5;
string = 8;
builder = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && TRUE != FIELD

error && mask & bits

finished && num * offset

flag && finished + OFFSET

TRUE && started < val

remember would refer back not seen

  string =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

saw = 5;
screwdriver = 9;
tangent = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && started << length

finished && TRUE ^ flags

2 * count && finished

finished && flags | finished

count % 2 + count

remember would refer back not seen

  screwdriver =     ____    __    __

  tangent =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

blue = 9;
green = 8;
red = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && flag || started

length * rate < temp

mask & options != temp

count * done << 0xff

length * error ^ state

remember would refer back not seen

  red =     ____    __    __

  report =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

sofa = 4;
chair = 5;
wheel = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * started | flag

rate * started || finished

started << bits + 2

length + n != val

flag << temp < offset

remember would refer back not seen

  wheel =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

sweden = 5;
occult = 6;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + flags & options

2 << options ^ done

2 + done && started

num << OPTIONS | options

done << started || TRUE

remember would refer back not seen

  germany =     ____    __    __

  occult =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

saddle = 9;
jupiter = 4;
mars = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < val != field

resource < flag & state

n != val & done

bits ^ BITS << num

val < resource && started

remember would refer back not seen

  mars =     ____    __    __

  jupiter =     ____    __    __

  saddle =     ____    __    __

  venus =     ____    __    __

sheep = 6;
pig = 5;
chapter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != 7 && done

0xff ^ flag | options

temp < count * rate

field != 2 * num

options ^ flag || error

remember would refer back not seen

  sheep =     ____    __    __

  cow =     ____    __    __

  chapter =     ____    __    __

  pig =     ____    __    __

fly = 5;
wasp = 4;
bee = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < rate + length

val != num + count

TRUE | temp != FIELD

7 != rate < length

flag | started & finished

remember would refer back not seen

  tail =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

blackbird = 9;
robin = 5;
sparrow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != val << NUM

started | flag && done

7 != flags ^ TRUE

done | finished * rate

val != state | FLAGS

remember would refer back not seen

  pencil =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

apple = 8;
pear = 4;
petrol = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || done | flag

MASK | done + count

N != temp || DONE

BITS | flag < NUM

state | error << 0xff

remember would refer back not seen

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

  petrol =     ____    __    __

minute = 8;
room = 9;
hour = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STATE & started && flag

done & 2 * offset

error & started + 2

started & temp < length

bits & started << finished

remember would refer back not seen

  second =     ____    __    __

  hour =     ____    __    __

  room =     ____    __    __

  minute =     ____    __    __

elm = 8;
chestnut = 4;
oak = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & flag ^ 0xff

started & TRUE | FLAGS

NUM + offset % num

OPTIONS & STARTED || TRUE

rate + val < field

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  hair =     ____    __    __

  oak =     ____    __    __

wax = 6;
january = 5;
june = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num / val != N

length + rate << offset

offset * num & started

offset + length ^ 0xff

num + length | flag

remember would refer back not seen

  june =     ____    __    __

  wax =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

liver = 8;
heart = 5;
lung = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + offset || TRUE

ERROR << 7 != n

count < 7 << 2

rate << bits & flags

temp < field ^ finished

remember would refer back not seen

  heart =     ____    __    __

  plastic =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

solitaire = 8;
atom = 5;
scrabble = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << done && finished

resource < offset | 0xff

mask << count % 2

rate < TRUE || finished

mask ^ finished != field

remember would refer back not seen

  solitaire =     ____    __    __

  poker =     ____    __    __

  atom =     ____    __    __

  scrabble =     ____    __    __

english = 9;
dutch = 5;
mandarin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ flag & mask

finished ^ flag && started

error | bits ^ state

error ^ done * num

options | TRUE || done

remember would refer back not seen

  dutch =     ____    __    __

  hot =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

adjective = 4;
verb = 9;
exterior = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR ^ length + rate

error || FIELD != resource

0xff ^ n < count

error || TRUE & flag

finished || error && flag

remember would refer back not seen

  exterior =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

shirt = 8;
propeller = 5;
trousers = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || length * COUNT

flag || TRUE + num

error || started < offset

error || LENGTH << offset

error || flag ^ STARTED

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  propeller =     ____    __    __

knife = 9;
spoon = 4;
snake = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && flag != resource

flag && TRUE & flag

finished && 2 * offset

STARTED && num + offset

DONE && n < rate

remember would refer back not seen

  snake =     ____    __    __

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

stream = 4;
plastic = 9;
river = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STARTED && finished << flag

error && started ^ done

2 * offset && error

finished && started | ERROR

2 * rate + offset

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  plastic =     ____    __    __

string = 4;
builder = 9;
painter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && error || done

offset * field < offset

started & MASK != 7

rate % count << RATE

2 * offset ^ started

remember would refer back not seen

  string =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

hammer = 6;
saw = 8;
screwdriver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * 2 | TRUE

length * OFFSET || done

rate << offset + rate

offset + temp != resource

bits << flag < length

remember would refer back not seen

  tangent =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

green = 6;
hot = 4;
blue = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & length - NUM

TRUE && bits | done

done || flag | error

temp < 0xff << finished

rate - done | TRUE

remember would refer back not seen

  green =     ____    __    __

  red =     ____    __    __

  blue =     ____    __    __

  hot =     ____    __    __

table = 8;
sofa = 9;
chair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ flag && done

2 - done || flag

NUM / state | bits

temp == n / count

2 << OPTIONS ^ flag

remember would refer back not seen

  sofa =     ____    __    __

  membrane =     ____    __    __

  chair =     ____    __    __

  table =     ____    __    __

sweden = 6;
france = 9;
wood = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == done | flag

options ^ done | bits

resource < n - offset

2 / 0xff & finished

done || 0xff ^ bits

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  wood =     ____    __    __

  sweden =     ____    __    __

engine = 8;
mars = 6;
jupiter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && n == resource

count / rate && started

started || 2 - count

7 == rate << flag

finished << options | state

remember would refer back not seen

  jupiter =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

  engine =     ____    __    __

pig = 9;
cow = 6;
sheep = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << finished && error

flags | flag < 2

length - offset << length

TRUE & mask | started

mask | 0xff ^ flags

remember would refer back not seen

  exterior =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

fly = 9;
wasp = 5;
bee = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * count == n

finished && length < num

count - num * 2

7 == val < 2

done || field < length

remember would refer back not seen

  bee =     ____    __    __

  fly =     ____    __    __

  petrol =     ____    __    __

  wasp =     ____    __    __

wax = 8;
blackbird = 6;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || flag && finished

error | flag * count

finished | temp == resource

flag ^ resource == field

flag && error || done

remember would refer back not seen

  robin =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  wax =     ____    __    __

propeller = 4;
pear = 6;
apple = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count - num == temp

n < length == field

options | finished && error

FLAGS ^ mask << offset

num < 2 ^ flag

remember would refer back not seen

  propeller =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

second = 6;
grass = 8;
minute = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < FINISHED || started

OFFSET << state & mask

mask ^ NUM * count

state ^ started || flag

num < TRUE && finished

remember would refer back not seen

  second =     ____    __    __

  grass =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

plastic = 5;
elm = 4;
chestnut = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - offset && error

temp < offset & done

num - offset & options

rate * num - rate

7 == field || started

remember would refer back not seen

  plastic =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

june = 4;
pencil = 6;
october = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || 0xff & mask

done & options && started

FLAG | state << started

flag && ERROR << flag

num * started ^ options

remember would refer back not seen

  june =     ____    __    __

  pencil =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

snake = 4;
heart = 8;
liver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | state & started

started || finished == field

finished & state ^ flags

length - offset ^ started

done && error * length

remember would refer back not seen

  snake =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

solitaire = 9;
fence = 8;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < n * length

mask << field == temp

mask & temp < n

finished && error & finished

val == field ^ flag

remember would refer back not seen

  solitaire =     ____    __    __

  fence =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

english = 6;
dutch = 8;
wheel = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && started ^ 0xff

mask ^ num < resource

rate % length || started

flags & TRUE * rate

mask | TRUE - length

remember would refer back not seen

  mandarin =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

  wheel =     ____    __    __

occult = 8;
adjective = 5;
verb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || num / length

BITS ^ flag - 2

0xff ^ state & started

state << length < 2

offset << started - count

remember would refer back not seen

  verb =     ____    __    __

  noun =     ____    __    __

  occult =     ____    __    __

  adjective =     ____    __    __

tangent = 5;
trousers = 9;
dress = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || FINISHED << state

length - resource < length

bits << finished || error

0xff & options << TRUE

7 == field - rate

remember would refer back not seen

  shirt =     ____    __    __

  tangent =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

knife = 4;
spoon = 6;
hair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & state == field

DONE & done || started

NUM * 2 < num

n == field && finished

length < resource | OPTIONS

remember would refer back not seen

  fork =     ____    __    __

  hair =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

atom = 5;
stream = 9;
river = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

VAL == resource & state

finished && num - 2

OFFSET << count % length

NUM * 0xff << length

options | flag || error

remember would refer back not seen

  river =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

  atom =     ____    __    __

builder = 6;
painter = 8;
plastic = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & finished && done

finished & 0xff % length

state & LENGTH - 2

error & started < 7

done & length << bits

remember would refer back not seen

  builder =     ____    __    __

  plumber =     ____    __    __

  plastic =     ____    __    __

  painter =     ____    __    __

screwdriver = 4;
pencil = 5;
hammer = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS & started == resource

started & 0xff ^ flags

count - offset * 2

flags & finished | STARTED

length - resource < 2

remember would refer back not seen

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

  pencil =     ____    __    __

red = 5;
green = 8;
tail = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & flag || TRUE

NUM - num << 2

offset * bits & error

2 - length == resource

LENGTH - rate ^ mask

remember would refer back not seen

  red =     ____    __    __

  blue =     ____    __    __

  tail =     ____    __    __

  green =     ____    __    __

sofa = 4;
wheel = 6;
chair = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count - mask | options

rate - done || error

resource < length << 2

finished << done & TRUE

num < field == val

remember would refer back not seen

  table =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

  wheel =     ____    __    __

germany = 6;
sweden = 8;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags << TRUE && error

2 < length ^ TRUE

BITS << rate * offset

FIELD < options | 0xff

2 < offset || flag

remember would refer back not seen

  saddle =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

mars = 5;
venus = 9;
comb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == flag & finished

val == resource && flag

done && 0xff & flag

flags ^ 7 == field

field == 2 * offset

remember would refer back not seen

  jupiter =     ____    __    __

  comb =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

cow = 5;
sheep = 4;
hair = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && started * 2

started ^ finished | state

field == temp - rate

done && flag - num

flag ^ finished || TRUE

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  hair =     ____    __    __

bee = 8;
engine = 9;
wasp = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == n < 7

done && num < count

state | 0xff & mask

started && flag << options

mask | TRUE && error

remember would refer back not seen

  bee =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

  engine =     ____    __    __

sparrow = 4;
string = 5;
robin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && N == n

mask | error / length

done && error ^ state

started | mask - 2

done && started | FINISHED

remember would refer back not seen

  string =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

banana = 4;
apple = 5;
pear = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || TRUE | started

FLAG | 7 < field

TRUE && flag || finished

error | OPTIONS << 2

bits | options == 7

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  petrol =     ____    __    __

  pear =     ____    __    __

minute = 5;
pencil = 6;
second = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RATE * started && done

offset / length - offset

rate * length < field

num * options << offset

offset % 7 == resource

remember would refer back not seen

  second =     ____    __    __

  minute =     ____    __    __

  pencil =     ____    __    __

  hour =     ____    __    __

room = 6;
oak = 5;
chestnut = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * state ^ flag

rate * 2 | error

flag << mask - rate

count * num || TRUE

state << temp < offset

remember would refer back not seen

  room =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

report = 4;
october = 5;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - offset & finished

length << DONE == val

2 - length && done

0xff << num ^ flags

TRUE << length | flag

remember would refer back not seen

  report =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

lung = 4;
heart = 9;
grass = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM << 2 || finished

n < offset & bits

field == error << MASK

rate < flag && started

temp == n ^ finished

remember would refer back not seen

  lung =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

  grass =     ____    __    __

scrabble = 4;
snake = 9;
solitaire = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < LENGTH * length

n == FIELD | error

temp < offset - rate

n == started || error

mask ^ TRUE & bits

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  snake =     ____    __    __

  solitaire =     ____    __    __

english = 8;
mandarin = 4;
hot = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ done && TRUE

started ^ offset * num

flags | 0xff ^ TRUE

started ^ offset - num

started | TRUE || started

remember would refer back not seen

  dutch =     ____    __    __

  english =     ____    __    __

  hot =     ____    __    __

  mandarin =     ____    __    __

noun = 8;
adjective = 5;
wax = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ num < count

error || FLAGS & 0xff

finished ^ error << 2

error || started && done

started || LENGTH * rate

remember would refer back not seen

  verb =     ____    __    __

  wax =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

occult = 9;
trousers = 8;
dress = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || error - 2

flag || count < n

error || started << count

done || flag == resource

finished || error ^ finished

remember would refer back not seen

  trousers =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

  occult =     ____    __    __

spoon = 9;
knife = 6;
lizard = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & TRUE && done

bits & count * RATE

mask & num - 2

0xff & finished < field

FINISHED & flags << length

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  lizard =     ____    __    __

fence = 8;
river = 6;
canal = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & resource == TEMP

done & finished ^ done

length - rate % 2

started & state | done

num - val < count

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  fence =     ____    __    __

plumber = 8;
plastic = 9;
builder = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & finished || flag

LENGTH - TRUE << 2

length * flag & flags

rate - num == 7

offset - rate ^ flag

remember would refer back not seen

  plumber =     ____    __    __

  builder =     ____    __    __

  plastic =     ____    __    __

  painter =     ____    __    __

pencil = 5;
screwdriver = 8;
saw = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - length | mask

length - STARTED || error

count < val << num

0xff << flag & bits

2 < resource == temp

remember would refer back not seen

  hammer =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

  pencil =     ____    __    __

green = 6;
blue = 8;
saddle = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits | error || TRUE

val != 7 | bits

0xff << state ^ error

count - offset << flags

2 - rate * 2

remember would refer back not seen

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

  saddle =     ____    __    __

table = 4;
sofa = 6;
chapter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || error << rate

STATE & options && done

rate - num & FLAG

flag | done && TRUE

offset * done << rate

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  chapter =     ____    __    __

germany = 4;
fence = 6;
france = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && n < count

rate * count || done

flags & OPTIONS ^ error

temp < resource || finished

STARTED || error + 2

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

  fence =     ____    __    __

jupiter = 4;
mars = 5;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & rate < offset

count * 7 < temp

done << num % count

rate - 0xff ^ started

TRUE | 2 + count

remember would refer back not seen

  occult =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

pig = 8;
sheep = 6;
exterior = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != temp == resource

offset < finished | mask

finished ^ options << error

TRUE || length < field

NUM * LENGTH ^ started

remember would refer back not seen

  pig =     ____    __    __

  exterior =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

fly = 8;
wasp = 4;
bee = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - mask | flags

7 < state << rate

state | flags * num

finished & temp == 7

flag & started + num

remember would refer back not seen

  grass =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

report = 9;
robin = 5;
blackbird = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ mask + NUM

started | state & TRUE

error ^ state == val

flag << 2 | mask

flag ^ error * offset

remember would refer back not seen

  sparrow =     ____    __    __

  report =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

plastic = 9;
banana = 4;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != 7 << mask

flag ^ TRUE || finished

val < STARTED && finished

done || temp == RESOURCE

length / 2 && finished

remember would refer back not seen

  plastic =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

second = 6;
minute = 5;
membrane = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff << bits == field

n != 0xff & mask

flag & num * 2

options | bits ^ flag

flag << started && done

remember would refer back not seen

  second =     ____    __    __

  membrane =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

elm = 8;
chestnut = 4;
oak = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count << finished & 0XFF

flags & STATE << offset

TRUE ^ mask | finished

error && finished | error

count - num && started

remember would refer back not seen

  chestnut =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

  propeller =     ____    __    __

june = 8;
october = 6;
january = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR || flag && TRUE

7 < error ^ mask

flag || started * 2

TRUE || error & flag

mask ^ done && error

remember would refer back not seen

  october =     ____    __    __

  wax =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

snake = 6;
heart = 4;
lung = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * count == temp

finished | flag < val

done ^ TRUE & 0xff

flag && num + 2

val != 7 < n

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

  snake =     ____    __    __

scrabble = 4;
poker = 5;
tail = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 != val && TRUE

0xff | bits == temp

temp < state & done

2 - num || finished

temp != val || flag

remember would refer back not seen

  poker =     ____    __    __

  tail =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

engine = 6;
english = 5;
mandarin = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started ^ bits < val

resource < num + offset

finished && error & state

num - temp == n

length - offset < resource

remember would refer back not seen

  mandarin =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

  engine =     ____    __    __

verb = 4;
adjective = 8;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != field * length

started && options ^ flag

flag && done || flag

options << count || error

FLAG && TRUE * 2

remember would refer back not seen

  noun =     ____    __    __

  petrol =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

dress = 5;
shirt = 9;
trousers = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != offset + count

flag || OPTIONS | done

error && finished << mask

rate - count + 2

num << error < num

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  wood =     ____    __    __

  dress =     ____    __    __

knife = 4;
occult = 5;
fork = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * offset & error

error || flags ^ bits

temp < val == temp

error && FINISHED == temp

n != temp ^ mask

remember would refer back not seen

  knife =     ____    __    __

  occult =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

pencil = 4;
river = 5;
stream = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * DONE | bits

num * 2 + length

started & 0xff || FLAG

flags & finished | options

offset < num / 2

remember would refer back not seen

  stream =     ____    __    __

  pencil =     ____    __    __

  canal =     ____    __    __

  river =     ____    __    __

painter = 4;
plumber = 9;
saddle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != temp || flag

flag && finished & done

started && FLAG * LENGTH

done && RATE + count

finished && offset < RESOURCE

remember would refer back not seen

  plumber =     ____    __    __

  saddle =     ____    __    __

  builder =     ____    __    __

  painter =     ____    __    __

screwdriver = 6;
propeller = 9;
hammer = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && FLAG << 2

flag && field == temp

LENGTH * done && error

finished && done ^ flags

num * length + offset

remember would refer back not seen

  propeller =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

red = 8;
green = 4;
blue = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && started | bits

count * 2 < resource

error && started || flag

count * length << TRUE

2 * 7 == resource

remember would refer back not seen

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

  membrane =     ____    __    __

sofa = 6;
fence = 9;
chair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * 2 ^ bits

offset * state | done

count << mask % length

offset * FLAG || STARTED

state << rate + num

remember would refer back not seen

  fence =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

occult = 4;
sweden = 9;
france = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RATE - 2 & options

2 << num < val

2 - length && started

rate << 7 == temp

rate << state ^ 0xff

remember would refer back not seen

  occult =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

mars = 9;
chapter = 6;
jupiter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << bits | TRUE

state << done || flag

temp != STARTED & options

mask ^ bits < N

count < TRUE & finished

remember would refer back not seen

  venus =     ____    __    __

  chapter =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

pig = 6;
cow = 4;
grass = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FIELD != finished && TRUE

STATE ^ mask << error

count < TRUE && error

n != 2 % rate

flag ^ resource == N

remember would refer back not seen

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  grass =     ____    __    __

bee = 8;
fly = 4;
occult = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < count / 2

val != length + num

state ^ flag | 0xff

val != num < offset

done ^ TRUE || started

remember would refer back not seen

  occult =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

robin = 9;
wax = 8;
sparrow = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != started << state

error | state & started

field != val == temp

TRUE | error && flag

n != bits ^ state

remember would refer back not seen

  wax =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

pear = 6;
snake = 5;
apple = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || field == val

done | finished * count

val != field | flag

FLAG || flag ^ error

options | done + count

remember would refer back not seen

  banana =     ____    __    __

  apple =     ____    __    __

  snake =     ____    __    __

  pear =     ____    __    __

atom = 9;
second = 6;
hour = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || started | state

flag | BITS < TEMP

FINISHED & done && started

error & 2 * offset

done & num + offset

remember would refer back not seen

  atom =     ____    __    __

  second =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

tangent = 6;
elm = 4;
chestnut = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & BITS < rate

mask & TRUE << 0xff

TRUE & 7 == n

options & state ^ started

offset - num % rate

remember would refer back not seen

  oak =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

  tangent =     ____    __    __

plastic = 4;
october = 8;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & finished | bits

num - COUNT + offset

0xff & flag || TRUE

offset - count < n

2 / rate & FINISHED

remember would refer back not seen

  plastic =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

exterior = 4;
liver = 8;
heart = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset - count << flags

count - temp == val

length - count ^ flag

rate - num | options

2 < count + rate

remember would refer back not seen

  lung =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

  exterior =     ____    __    __

solitaire = 6;
scrabble = 5;
poker = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - TRUE || ERROR

resource < 0xff << done

STARTED << options & flags

offset < n == val

flags << offset && TRUE

remember would refer back not seen

  scrabble =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

  lizard =     ____    __    __

dutch = 8;
tail = 4;
mandarin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET < mask ^ flags

resource < started | flag

num < finished || TRUE

bits ^ started & mask

FINISHED | state << count

remember would refer back not seen

  english =     ____    __    __

  tail =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

verb = 6;
noun = 9;
room = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ started && flag

state | finished == VAL

state ^ 0xff % LENGTH

TRUE | started ^ flag

TRUE ^ started + count

remember would refer back not seen

  verb =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

  room =     ____    __    __

dress = 5;
shirt = 9;
trousers = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | finished || error

finished || flag & flags

done || error && started

flag || num * 2

DONE || done + 2

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  report =     ____    __    __

knife = 5;
fork = 6;
hair = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource != finished || done

finished && options & state

started && rate / 2

flag && done + offset

TRUE && started < 7

remember would refer back not seen

  fork =     ____    __    __

  hair =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

river = 4;
canal = 8;
stream = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && started << flag

finished && flag == resource

2 * offset && error

error && flag ^ error

num * offset + NUM

remember would refer back not seen

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

  wheel =     ____    __    __

plumber = 6;
painter = 4;
builder = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && TRUE | flag

count * offset < 2

done && TRUE || STARTED

count % NUM << error

rate % 7 == n

remember would refer back not seen

  painter =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  saddle =     ____    __    __

saw = 8;
hammer = 9;
screwdriver = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num / done ^ started

2 * 0xff | flag

num << count * 2

num * 2 || error

TRUE << options + count

remember would refer back not seen

  propeller =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

green = 5;
blue = 6;
red = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

BITS & options + 2

rate * started ^ options

STARTED << options | TRUE

num < VAL & TRUE

finished | offset + 2

remember would refer back not seen

  green =     ____    __    __

  red =     ____    __    __

  blue =     ____    __    __

  tail =     ____    __    __

sofa = 8;
chair = 5;
table = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits ^ FLAGS + 2

TRUE || flag * num

val < resource * 2

7 != n == temp

count % rate || ERROR

remember would refer back not seen

  report =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

exterior = 4;
germany = 6;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != count << STARTED

BITS & mask | TRUE

finished && flag / rate

options | flags ^ started

mask | OPTIONS << mask

remember would refer back not seen

  france =     ____    __    __

  exterior =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

jupiter = 4;
membrane = 9;
mars = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && error << done

num < temp << length

finished || TRUE + RATE

count * length && error

flag && finished || error

remember would refer back not seen

  membrane =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

fence = 8;
cow = 5;
pig = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != field || error

done || options ^ bits

num - offset && TRUE

options << done && flag

finished && done < 7

remember would refer back not seen

  fence =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

plastic = 9;
bee = 6;
wasp = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TEMP != started ^ state

started | offset % num

length - count | BITS

val != resource * offset

offset * rate + 2

remember would refer back not seen

  bee =     ____    __    __

  wasp =     ____    __    __

  plastic =     ____    __    __

  fly =     ____    __    __

blackbird = 6;
sparrow = 5;
robin = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits ^ state << started

bits << TRUE ^ options

rate << state || finished

7 != length < temp

TRUE && STATE ^ TRUE

remember would refer back not seen

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  wax =     ____    __    __

banana = 4;
apple = 5;
petrol = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * offset << 2

done ^ started || flag

TRUE || flag && done

started && flags & STATE

flag && ERROR | mask

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  petrol =     ____    __    __

  pear =     ____    __    __

second = 5;
hour = 8;
propeller = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num % count == 7

count - val == resource

started << offset * 2

TRUE & state ^ done

done & field == 7

remember would refer back not seen

  second =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

  propeller =     ____    __    __

elm = 4;
chestnut = 5;
oak = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags | finished < 2

started || flag << error

2 * options | STARTED

num < val || started

state | resource == n

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  snake =     ____    __    __

  oak =     ____    __    __

january = 6;
hot = 5;
june = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ finished | TRUE

resource < error | finished

bits << field == n

num - error ^ 0xff

n != options & FLAGS

remember would refer back not seen

  october =     ____    __    __

  june =     ____    __    __

  hot =     ____    __    __

  january =     ____    __    __

lung = 8;
plastic = 6;
liver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ finished && STARTED

TRUE ^ done & mask

val < field ^ TRUE

flag || temp < num

mask | done && error

remember would refer back not seen

  plastic =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

solitaire = 6;
occult = 8;
scrabble = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | TRUE || error

2 - rate << FLAGS

offset < TRUE && started

flag || error & flag

LENGTH - finished & options

remember would refer back not seen

  scrabble =     ____    __    __

  occult =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

english = 4;
comb = 8;
mandarin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || finished | bits

0xff & TRUE && FLAG

0xff << resource < RESOURCE

done << flag & options

started & 0xff << done

remember would refer back not seen

  comb =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

verb = 9;
adjective = 6;
pencil = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & error || started

done && error + count

error & TRUE * rate

count - 2 * length

resource < length == resource

remember would refer back not seen

  adjective =     ____    __    __

  pencil =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

dress = 6;
shirt = 9;
chapter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ options == val

resource != 7 + num

length - num < length

flags & flag < 2

length / 2 & bits

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

  chapter =     ____    __    __

hair = 9;
knife = 8;
fork = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || done == temp

state ^ count < NUM

mask | state & started

offset * 2 < 7

length - num + RATE

remember would refer back not seen

  knife =     ____    __    __

  hair =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

stream = 8;
river = 6;
grass = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ count % offset

7 != done && ERROR

field != val | options

finished << num + 2

started && finished == n

remember would refer back not seen

  river =     ____    __    __

  grass =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

plumber = 5;
report = 9;
painter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != error || started

done && started & flags

error && length * rate

error && count + offset

error && done < 2

remember would refer back not seen

  builder =     ____    __    __

  report =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

hammer = 8;
screwdriver = 6;
membrane = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && started << 2

finished && FLAG == temp

offset % count && started

TRUE && started ^ TRUE

num * offset + count

remember would refer back not seen

  hammer =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

  membrane =     ____    __    __

atom = 4;
red = 8;
green = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && TRUE | finished

offset * resource < NUM

finished && error || flag

count * num << 0xff

rate * temp == resource

remember would refer back not seen

  atom =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

kettle = 5;
table = 4;
sofa = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * offset ^ 0xff

length * 2 | started

done << flags * 2

rate / offset || error

options << rate + NUM

remember would refer back not seen

  table =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

  kettle =     ____    __    __

tangent = 8;
germany = 6;
sweden = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - count & done

num << error < NUM

2 - num && error

offset << 7 == n

options << started ^ TRUE

remember would refer back not seen

  tangent =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

jupiter = 6;
venus = 8;
mars = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count << mask | flag

done << TRUE || error

VAL != temp & bits

state ^ 2 < rate

field < mask & 0XFF

remember would refer back not seen

  mars =     ____    __    __

  lizard =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

sheep = 6;
string = 8;
pig = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 != done && finished

started ^ TRUE << count

LENGTH < length && FINISHED

resource != length * count

error ^ n == val

remember would refer back not seen

  sheep =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

  string =     ____    __    __

bee = 5;
wasp = 8;
snake = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < 7 * rate

n != 7 + count

done ^ options | finished

7 != num < count

TRUE ^ finished || done

remember would refer back not seen

  wasp =     ____    __    __

  bee =     ____    __    __

  snake =     ____    __    __

  fly =     ____    __    __

hot = 5;
robin = 9;
blackbird = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource != val << count

state | started & state

7 != resource == field

flag | bits && flag

val != RESOURCE ^ mask

remember would refer back not seen

  hot =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

apple = 4;
occult = 8;
banana = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || temp == RESOURCE

options | state * rate

resource != 7 | flags

TRUE || finished ^ OPTIONS

TRUE | num + count

remember would refer back not seen

  pear =     ____    __    __

  occult =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

minute = 9;
second = 6;
fence = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || done | 0xff

error | 2 < n

MASK & TRUE && flag

bits & rate * length

flags & rate + offset

remember would refer back not seen

  fence =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

oak = 5;
chestnut = 8;
elm = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & 2 < rate

done & state << finished

TRUE & 7 == field

bits & flags ^ FINISHED

2 - offset * length

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  pencil =     ____    __    __

  oak =     ____    __    __

june = 4;
october = 9;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & bits | finished

length - count + offset

finished & started || flag

offset - count < 7

count * num & finished

remember would refer back not seen

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

  wheel =     ____    __    __

occult = 5;
heart = 4;
liver = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - length << done

2 - offset == val

offset - finished ^ DONE

2 - rate | options

rate < count + rate

remember would refer back not seen

  occult =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

comb = 5;
solitaire = 4;
scrabble = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - 2 || TRUE

val < OPTIONS << FLAGS

offset << STATE & bits

field < temp == field

length << flag && done

remember would refer back not seen

  solitaire =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

  comb =     ____    __    __

dutch = 4;
mandarin = 8;
english = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < bits ^ 0xff

n < mask | error

val < count || started

mask ^ options & started

finished | TRUE << 0xff

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  saddle =     ____    __    __

adjective = 8;
verb = 9;
plastic = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask ^ done && error

flags | N == field

mask ^ state * num

flags | started ^ finished

finished ^ options + rate

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

  plastic =     ____    __    __

shirt = 8;
dress = 9;
trousers = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | TRUE || finished

started || error & bits

flag || done && finished

finished || rate * num

error || offset + rate

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  tail =     ____    __    __

  dress =     ____    __    __

engine = 6;
spoon = 9;
fork = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 != field || error

finished && error & started

flag && rate * 2

TRUE && started + length

started && TRUE < RESOURCE

remember would refer back not seen

  engine =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

grass = 9;
canal = 5;
river = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FINISHED && done << 2

TRUE && finished == field

count * flag && error

TRUE && flag ^ done

num * rate + length

remember would refer back not seen

  river =     ____    __    __

  stream =     ____    __    __

  grass =     ____    __    __

  canal =     ____    __    __

plumber = 8;
report = 4;
builder = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && error | OPTIONS

rate % TEMP < rate

done && flag || TRUE

count * 2 << BITS

rate * RATE == val

remember would refer back not seen

  plumber =     ____    __    __

  report =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

hammer = 4;
membrane = 5;
saw = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * count ^ flags

rate / count | mask

mask << num % length

rate % num || DONE

started << num + length

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  membrane =     ____    __    __

  hammer =     ____    __    __

blue = 9;
red = 8;
wax = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ val < RATE

rate + offset & started

error && flag | state

rate + offset | MASK

flags | started & STATE

remember would refer back not seen

  green =     ____    __    __

  wax =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

table = 4;
lizard = 5;
sofa = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * 0xff << flags

num * temp == val

flag | TRUE + rate

started ^ flag * 2

bits << rate | bits

remember would refer back not seen

  table =     ____    __    __

  lizard =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

france = 9;
string = 6;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < TRUE && error

finished & MASK << flag

num << OFFSET * length

finished && done & error

length < 7 | TRUE

remember would refer back not seen

  sweden =     ____    __    __

  string =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

venus = 6;
jupiter = 4;
saddle = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | resource == field

done ^ started | OPTIONS

TRUE ^ 7 == field

rate < temp || started

length << 2 + rate

remember would refer back not seen

  mars =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

  saddle =     ____    __    __

pig = 5;
cow = 9;
sheep = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length % rate < length

flag || TRUE ^ state

STATE << 0xff & state

FLAG || started + rate

flag && done << TRUE

remember would refer back not seen

  cow =     ____    __    __

  grass =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

bee = 6;
fly = 5;
wasp = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask | 0xff < rate

flags ^ TRUE && error

options & flag < length

bits ^ length << mask

length + RATE ^ state

remember would refer back not seen

  occult =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

blackbird = 8;
sparrow = 4;
tangent = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == offset % 2

started & error | finished

flag || FLAG << num

error || RESOURCE == val

TRUE ^ done & started

remember would refer back not seen

  sparrow =     ____    __    __

  tangent =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

engine = 8;
apple = 9;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * num | mask

TRUE | done ^ TRUE

flag & finished * 2

offset % num || flag

7 == rate << length

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

  engine =     ____    __    __

hour = 5;
minute = 4;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & TRUE && flag

2 + rate * 2

rate * count & options

FIELD < temp ^ started

error << flag && FINISHED

remember would refer back not seen

  kettle =     ____    __    __

  second =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

plastic = 9;
chestnut = 4;
elm = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && done * length

length + finished && flag

NUM * count && TRUE

rate + offset == temp

offset + started || flag

remember would refer back not seen

  plastic =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

petrol = 6;
october = 8;
june = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || flag < temp

started | flag || started

flag && started + rate

resource == n ^ TRUE

flag & OPTIONS + length

remember would refer back not seen

  october =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

  petrol =     ____    __    __

lung = 4;
atom = 9;
liver = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK << STATE ^ bits

DONE && done || error

finished && n == 7

started || DONE && done

rate * num ^ TRUE

remember would refer back not seen

  atom =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

solitaire = 5;
scrabble = 8;
poker = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ length + count

finished | bits * length

DONE || error | state

finished && num < offset

num < resource + offset

remember would refer back not seen

  poker =     ____    __    __

  wheel =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

dutch = 6;
english = 5;
snake = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == temp | mask

flag << length == temp

N < MASK << state

rate * count + 2

resource == flag || finished

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  snake =     ____    __    __

  english =     ____    __    __

noun = 9;
verb = 8;
adjective = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || num * length

offset + error << state

val == TRUE && finished

options << count < resource

finished & error || flag

remember would refer back not seen

  verb =     ____    __    __

  hot =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

dress = 9;
trousers = 4;
wood = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || error & started

resource == n < 7

done << finished || FINISHED

offset < finished & flag

error && started ^ bits

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  wood =     ____    __    __

tail = 5;
knife = 9;
fork = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < temp == field

0xff | length << options

state & 7 == field

TRUE ^ error || finished

length + count < 7

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  tail =     ____    __    __

river = 6;
hair = 4;
stream = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & options ^ STATE

field == n + length

n < offset * 2

val == field & bits

options | started && flag

remember would refer back not seen

  river =     ____    __    __

  stream =     ____    __    __

  hair =     ____    __    __

  canal =     ____    __    __

painter = 6;
tangent = 9;
builder = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & started && error

bits & num / offset

error & length + offset

MASK & done < temp

state & flags << MASK

remember would refer back not seen

  plumber =     ____    __    __

  painter =     ____    __    __

  tangent =     ____    __    __

  builder =     ____    __    __

saw = 5;
string = 8;
hammer = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & temp == val

flags & options ^ TRUE

num + count * 2

flag & state | options

count + num < field

remember would refer back not seen

  saw =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  string =     ____    __    __

red = 8;
blue = 4;
hot = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & done || TRUE

num + rate << length

count % rate & bits

count + rate == val

2 + offset ^ ERROR

remember would refer back not seen

  green =     ____    __    __

  red =     ____    __    __

  blue =     ____    __    __

  hot =     ____    __    __

hair = 5;
chair = 8;
table = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + offset | error

num + 2 || flag

length < started << mask

rate << state & mask

n < rate == val

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  hair =     ____    __    __

fence = 4;
france = 9;
sweden = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask << flags && ERROR

n < 7 ^ done

done << 2 * num

temp < n | flag

resource < flag || done

remember would refer back not seen

  germany =     ____    __    __

  fence =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

jupiter = 4;
mars = 8;
venus = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == 7 & flags

7 == finished && flag

TRUE && mask & OPTIONS

STATE ^ 7 == temp

val == num * rate

remember would refer back not seen

  lizard =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

pig = 9;
cow = 8;
sheep = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && done * count

options ^ 0xff | options

field == length + 2

TRUE && rate + 2

error ^ ERROR || error

remember would refer back not seen

  pig =     ____    __    __

  comb =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

fly = 5;
wasp = 4;
bee = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == temp < field

finished && n < resource

bits | done & state

started && flags << 0xff

TRUE | flag && error

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  occult =     ____    __    __

  bee =     ____    __    __

robin = 8;
snake = 4;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && 7 == n

done | mask % offset

finished && done ^ flags

done | flags + 2

flag && started | flag

remember would refer back not seen

  robin =     ____    __    __

  sparrow =     ____    __    __

  snake =     ____    __    __

  blackbird =     ____    __    __

apple = 4;
banana = 8;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || flag | finished

bits | val < count

TRUE && error || finished

error | flags << 2

started | 7 == val

remember would refer back not seen

  pear =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  engine =     ____    __    __

minute = 8;
second = 9;
hour = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * offset && TRUE

NUM * LENGTH + COUNT

num * 7 < resource

count * started << error

offset / count == resource

remember would refer back not seen

  hour =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  chapter =     ____    __    __

saddle = 4;
oak = 6;
elm = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length % count ^ started

count * OFFSET | FLAGS

done << 2 + num

count * num || finished

0xff << offset < val

remember would refer back not seen

  oak =     ____    __    __

  chestnut =     ____    __    __

  saddle =     ____    __    __

  elm =     ____    __    __

january = 6;
atom = 5;
june = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + state & error

flags << 2 == resource

rate + count && started

2 << started ^ finished

state << options | flag

remember would refer back not seen

  october =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

  atom =     ____    __    __

room = 9;
liver = 6;
lung = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num << 0xff || started

count < num & finished

field == length << error

rate < NUM && finished

field == temp ^ state

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  room =     ____    __    __

  heart =     ____    __    __

poker = 4;
plastic = 5;
scrabble = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < 2 * offset

field == flag | started

field < num + rate

resource == n || finished

flags ^ finished & mask

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  plastic =     ____    __    __

  solitaire =     ____    __    __

english = 5;
dutch = 8;
mandarin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS ^ bits && TRUE

flags ^ OFFSET * length

mask | 0xff ^ STATE

flag ^ 2 + length

bits | started || FINISHED

remember would refer back not seen

  grass =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

verb = 8;
kettle = 6;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ done < 2

started || TRUE & mask

done ^ finished << OFFSET

error || STARTED && error

error || flag * num

remember would refer back not seen

  noun =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

  kettle =     ____    __    __

shirt = 6;
petrol = 9;
trousers = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || TRUE + length

FINISHED || rate < offset

TRUE || 2 << rate

error || val == temp

done || TRUE ^ done

remember would refer back not seen

  trousers =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

  petrol =     ____    __    __

spoon = 6;
fork = 8;
knife = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & started && error

mask & started * count

options & finished + num

options & offset < 2

0xff & mask << length

remember would refer back not seen

  knife =     ____    __    __

  wood =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

stream = 4;
canal = 9;
occult = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & flags == n

finished & started ^ done

length + num * offset

bits & mask | TRUE

count + resource < val

remember would refer back not seen

  river =     ____    __    __

  canal =     ____    __    __

  occult =     ____    __    __

  stream =     ____    __    __

painter = 6;
builder = 9;
tangent = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & started || STARTED

offset + flag << 0XFF

num * TRUE & state

rate + RESOURCE == field

length + 0xff ^ error

remember would refer back not seen

  plumber =     ____    __    __

  tangent =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

saw = 6;
hammer = 4;
screwdriver = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + FLAGS | TRUE

NUM + FINISHED || TRUE

num < rate << done

num << flags & error

n < offset == val

remember would refer back not seen

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

  string =     ____    __    __

red = 6;
engine = 4;
blue = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset - flags ^ finished

flag & TRUE * num

2 - flags & flag

started ^ done & finished

offset * BITS | state

remember would refer back not seen

  green =     ____    __    __

  engine =     ____    __    __

  red =     ____    __    __

  blue =     ____    __    __

string = 5;
sofa = 6;
table = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | finished || done

STARTED && error | bits

count - rate + COUNT

done || rate + count

offset * num & bits

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

  string =     ____    __    __

germany = 5;
france = 6;
sweden = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & 2 + num

TRUE ^ mask && DONE

error || finished << count

length * num << options

n == 7 << error

remember would refer back not seen

  pencil =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

mars = 5;
jupiter = 9;
venus = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && resource != temp

num < temp && started

field == done && started

finished && 0xff ^ bits

count - STARTED || done

remember would refer back not seen

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

  wheel =     ____    __    __

saddle = 6;
cow = 4;
sheep = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * length != n

state & 7 < length

offset << error ^ started

finished | done != n

started && error < val

remember would refer back not seen

  pig =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

  saddle =     ____    __    __

fly = 4;
bee = 9;
snake = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STATE ^ error < COUNT

0xff ^ offset * num

count * num && finished

length << num < 7

num - STATE | flags

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  snake =     ____    __    __

  bee =     ____    __    __

sparrow = 8;
pencil = 4;
blackbird = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask | 7 < temp

2 - length << flag

2 * offset ^ started

flag || done && error

field < count % offset

remember would refer back not seen

  pencil =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

pear = 9;
tail = 5;
apple = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num - resource != 7

2 < offset != resource

mask | DONE ^ error

started || FLAG & flags

offset * 2 < resource

remember would refer back not seen

  tail =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

hour = 8;
second = 4;
minute = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RATE - finished && flag

n < val | 0xff

NUM * offset + rate

offset << flag * num

num < rate + count

remember would refer back not seen

  grass =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

elm = 4;
oak = 5;
plastic = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished | error << length

mask | 2 * offset

2 * TRUE || STARTED

resource == flag | bits

flag || count * OFFSET

remember would refer back not seen

  oak =     ____    __    __

  plastic =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

october = 9;
kettle = 5;
january = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < num << OFFSET

7 == field != temp

rate - resource < n

field == val < num

bits ^ FIELD != field

remember would refer back not seen

  october =     ____    __    __

  kettle =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

lung = 5;
heart = 4;
liver = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & bits | finished

error || finished ^ options

done && rate % offset

started || resource < field

VAL == RESOURCE + count

remember would refer back not seen

  exterior =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

poker = 5;
petrol = 8;
scrabble = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && count + length

done && finished & flags

0xff ^ error + count

field == finished || TRUE

bits & started || ERROR

remember would refer back not seen

  solitaire =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

  petrol =     ____    __    __

mandarin = 6;
dutch = 4;
english = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & bits && error

field == state & options

7 == val % num

temp == resource ^ 0xff

error && flag << offset

remember would refer back not seen

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

  comb =     ____    __    __

plastic = 6;
verb = 9;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count << bits + rate

bits << mask | error

offset < flag ^ flags

field < error & finished

val < length || TRUE

remember would refer back not seen

  verb =     ____    __    __

  adjective =     ____    __    __

  plastic =     ____    __    __

  noun =     ____    __    __

trousers = 8;
shirt = 4;
dress = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || DONE | mask

0xff | num + length

2 << n != field

finished | error & mask

0XFF ^ options || flag

remember would refer back not seen

  hot =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

knife = 5;
spoon = 8;
propeller = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR || done != val

offset - num * OFFSET

finished << rate && started

0xff & flag << 0xff

flag && TRUE || started

remember would refer back not seen

  knife =     ____    __    __

  propeller =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

stream = 5;
room = 8;
canal = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options << num & started

done & state ^ options

options << 2 || error

mask ^ error | bits

FINISHED | flag && finished

remember would refer back not seen

  room =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

exterior = 6;
painter = 8;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & 0xff != 7

TRUE & mask && done

finished & error * offset

flag & STATE + rate

flag & rate < 2

remember would refer back not seen

  builder =     ____    __    __

  exterior =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

saw = 8;
screwdriver = 6;
hammer = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & done << options

error & mask ^ flags

offset - error && TRUE

error & finished | flags

RATE - num * 2

remember would refer back not seen

  saw =     ____    __    __

  comb =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

chapter = 9;
blue = 6;
red = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK & error || STARTED

rate - num + rate

count * length != 7

length - offset < length

num - mask << num

remember would refer back not seen

  red =     ____    __    __

  blue =     ____    __    __

  chapter =     ____    __    __

  green =     ____    __    __

sofa = 5;
petrol = 6;
table = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - bits ^ mask

count - length | error

val < count / length

2 - TRUE || flag

resource < 7 + count

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  petrol =     ____    __    __

  sofa =     ____    __    __

sweden = 6;
france = 8;
germany = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << n != resource

resource < length << flag

TRUE << error & 0xff

length < state ^ options

temp < finished | flag

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  report =     ____    __    __

  germany =     ____    __    __

engine = 8;
venus = 9;
jupiter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < length || done

n == val != 7

done && resource != n

started ^ offset + rate

resource == TEMP & FLAG

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  engine =     ____    __    __

  mars =     ____    __    __

pig = 8;
sheep = 9;
saddle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && flag & mask

done ^ NUM < 7

n == TRUE && finished

finished && rate * num

STARTED ^ done << flag

remember would refer back not seen

  sheep =     ____    __    __

  saddle =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

tail = 5;
wasp = 4;
fly = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == 7 * num

done && count + offset

error ^ done | bits

started && flag < val

error ^ started || done

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  tail =     ____    __    __

  bee =     ____    __    __

blackbird = 8;
robin = 5;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && started << flag

FLAG | TRUE != n

started && done ^ options

started | error & options

done && error | mask

remember would refer back not seen

  wood =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

banana = 9;
room = 5;
apple = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || finished << offset

TRUE | done && flag

error && started || error

finished || flag ^ state

options | rate * count

remember would refer back not seen

  pear =     ____    __    __

  apple =     ____    __    __

  room =     ____    __    __

  banana =     ____    __    __

minute = 9;
second = 5;
fence = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || error | state

done | mask + num

length * num & mask

length * num && flag

offset * 2 + offset

remember would refer back not seen

  hour =     ____    __    __

  fence =     ____    __    __

  second =     ____    __    __

  minute =     ____    __    __

oak = 4;
pencil = 9;
chestnut = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * count < length

rate * 2 << length

length % OPTIONS ^ 0xff

num % state | finished

2 << TRUE && ERROR

remember would refer back not seen

  pencil =     ____    __    __

  oak =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

january = 4;
october = 5;
june = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count % STARTED || done

rate << 2 * rate

count - field != val

TRUE << STATE + 2

length - num & done

remember would refer back not seen

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

  grass =     ____    __    __

string = 4;
liver = 6;
lung = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << 7 < FIELD

num << TRUE ^ bits

started << mask | error

bits << state || error

field == n + offset

remember would refer back not seen

  string =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

wheel = 4;
poker = 6;
scrabble = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field < temp != val

val == N < field

length < TRUE & options

n == offset << options

num < TRUE && error

remember would refer back not seen

  solitaire =     ____    __    __

  wheel =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

english = 8;
kettle = 6;
dutch = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == bits ^ done

7 == BITS | flags

resource == 7 || finished

flags ^ finished != val

error | field < rate

remember would refer back not seen

  dutch =     ____    __    __

  kettle =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

verb = 8;
adjective = 5;
plastic = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask ^ flag & flags

state | flag << bits

done ^ started && flag

flag | mask ^ DONE

flags ^ done * length

remember would refer back not seen

  noun =     ____    __    __

  plastic =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

dress = 9;
pencil = 8;
trousers = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | bits || done

error || started != n

flag || done & options

done || error && finished

flag || 2 * offset

remember would refer back not seen

  trousers =     ____    __    __

  dress =     ____    __    __

  pencil =     ____    __    __

  shirt =     ____    __    __

knife = 5;
fork = 9;
spoon = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & resource != val

STATE & done && flag

flag & offset * num

done & count + length

bits & count < val

remember would refer back not seen

  spoon =     ____    __    __

  fork =     ____    __    __

  occult =     ____    __    __

  knife =     ____    __    __

hot = 8;
river = 5;
canal = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & count << error

flags & STATE ^ TRUE

length - finished && started

mask & options | error

rate - 2 * num

remember would refer back not seen

  hot =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

exterior = 8;
painter = 5;
builder = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & flag || ERROR

2 - count + num

rate / offset != n

2 - length < num

num - 2 << 0xff

remember would refer back not seen

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

  exterior =     ____    __    __

comb = 5;
hammer = 8;
saw = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num - finished ^ options

2 - done | flags

rate < n / rate

2 - flag || finished

offset < count + rate

remember would refer back not seen

  saw =     ____    __    __

  screwdriver =     ____    __    __

  comb =     ____    __    __

  hammer =     ____    __    __

wax = 5;
green = 6;
blue = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + rate & done

TRUE & 7 < 2

finished ^ bits << rate

rate + num * 2

0xff << mask * 2

remember would refer back not seen

  red =     ____    __    __

  wax =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

string = 6;
sofa = 9;
table = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0XFF << offset - COUNT

rate + 2 ^ TRUE

offset << flag ^ bits

temp != n == val

error & options ^ mask

remember would refer back not seen

  sofa =     ____    __    __

  chair =     ____    __    __

  string =     ____    __    __

  table =     ____    __    __

sweden = 4;
germany = 8;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < error & state

field != val - num

options | STATE == temp

started && error | finished

val != 2 << options

remember would refer back not seen

  hot =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

mars = 9;
petrol = 4;
jupiter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options ^ done | flag

TRUE && flag == n

done | finished ^ 0xff

finished && error ^ started

7 != n || finished

remember would refer back not seen

  mars =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  petrol =     ____    __    __

cow = 9;
sheep = 5;
report = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

LENGTH + N == resource

count + offset | done

n < length || finished

mask | finished || error

TRUE && FLAGS << state

remember would refer back not seen

  pig =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

  report =     ____    __    __

fly = 4;
bee = 9;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + 2 - offset

TRUE & started && ERROR

NUM < num ^ state

started || options << TRUE

STARTED ^ flags || started

remember would refer back not seen

  bee =     ____    __    __

  occult =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

sparrow = 5;
blackbird = 9;
snake = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != resource < n

options ^ RATE / offset

0xff | field < NUM

STATE ^ temp < 7

count * num - count

remember would refer back not seen

  robin =     ____    __    __

  snake =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

pencil = 8;
pear = 6;
apple = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * num & state

2 * length ^ mask

7 != val / OFFSET

options & started << length

num % length << error

remember would refer back not seen

  banana =     ____    __    __

  pencil =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

hour = 6;
grass = 9;
second = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || bits | error

mask & NUM - rate

val != FINISHED | flags

rate << flag | 0xff

offset << TRUE || started

remember would refer back not seen

  second =     ____    __    __

  grass =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

oak = 8;
elm = 9;
chestnut = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask ^ FLAG && done

options & error == field

error | finished && TRUE

num + count && started

error << started & finished

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  plastic =     ____    __    __

june = 4;
january = 9;
october = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < 2 * num

offset << RESOURCE == resource

state ^ num - count

TRUE || offset - 2

val < BITS << rate

remember would refer back not seen

  october =     ____    __    __

  january =     ____    __    __

  exterior =     ____    __    __

  june =     ____    __    __

liver = 5;
room = 4;
lung = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << offset && started

flag && started - num

finished || flag * 2

STARTED && started || flag

done & TRUE || started

remember would refer back not seen

  liver =     ____    __    __

  room =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

poker = 9;
scrabble = 8;
solitaire = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != done && started

offset * rate || done

flag || mask & options

resource < flag && done

TRUE && length % num

remember would refer back not seen

  wheel =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

english = 4;
mandarin = 9;
dutch = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < FIELD == n

num % FLAG && done

ERROR << count < offset

RATE / finished | state

count < bits | FLAGS

remember would refer back not seen

  dutch =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  fence =     ____    __    __

chapter = 6;
adjective = 4;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & STARTED * rate

state | FLAGS << rate

started || done && flag

OFFSET + offset << options

7 != n & TRUE

remember would refer back not seen

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  chapter =     ____    __    __

dress = 5;
comb = 6;
trousers = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | started / num

state | 2 - length

val != 7 ^ options

flag || TRUE == temp

done && FIELD < length

remember would refer back not seen

  shirt =     ____    __    __

  comb =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

fork = 9;
knife = 4;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options | error & flag

rate + offset < num

started && TRUE & OPTIONS

error || flag < TEMP

length + rate || TRUE

remember would refer back not seen

  knife =     ____    __    __

  occult =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

river = 5;
engine = 8;
stream = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS ^ finished == resource

2 % offset < n

TRUE || state ^ finished

2 * length == n

finished & 0xff | flags

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  engine =     ____    __    __

string = 8;
builder = 4;
painter = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 != finished || DONE

flag && done & state

done && finished % LENGTH

done && offset - count

error && finished < resource

remember would refer back not seen

  painter =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  string =     ____    __    __

hammer = 8;
comb = 9;
saw = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && flags << finished

flag && started == temp

length * error && done

error && flag ^ STARTED

offset * length - 2

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

  comb =     ____    __    __

red = 4;
blue = 9;
chapter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && DONE | MASK

length * n < count

error && finished || started

num * length << done

num * 2 == N

remember would refer back not seen

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  chapter =     ____    __    __

table = 5;
chair = 6;
petrol = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * bits ^ done

offset * state | flags

TRUE << num % count

num * TRUE || started

error << num - length

remember would refer back not seen

  petrol =     ____    __    __

  chair =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

france = 4;
germany = 6;
sweden = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT + BITS & bits

2 << bits < offset

num + offset && TRUE

options << 7 == resource

0xff << done ^ error

remember would refer back not seen

  engine =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

tangent = 8;
venus = 5;
mars = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state << offset | finished

error << 0xff || flag

VAL != error & done

state ^ mask < temp

resource < 2 & state

remember would refer back not seen

  jupiter =     ____    __    __

  tangent =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

sheep = 4;
report = 5;
cow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != started && error

state ^ flag << 0xff

count < done && error

resource != rate * COUNT

flag ^ temp == field

remember would refer back not seen

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  report =     ____    __    __

fly = 8;
room = 6;
wasp = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field < rate % offset

field != 7 - count

done ^ started | finished

7 != resource < num

error ^ flag || STARTED

remember would refer back not seen

  room =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

sparrow = 8;
membrane = 9;
blackbird = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != rate << started

mask | started & flag

val != 7 == VAL

MASK | flag && TRUE

resource != done ^ bits

remember would refer back not seen

  blackbird =     ____    __    __

  robin =     ____    __    __

  membrane =     ____    __    __

  sparrow =     ____    __    __

banana = 8;
pear = 6;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || val == field

STARTED | STATE % rate

resource != val | options

started || error ^ state

bits | length - COUNT

remember would refer back not seen

  banana =     ____    __    __

  occult =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

hour = 5;
minute = 6;
wheel = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || error | finished

options | finished < length

flag & error && started

done & offset * NUM

0xff & MASK - OFFSET

remember would refer back not seen

  minute =     ____    __    __

  wheel =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

elm = 6;
chestnut = 9;
kettle = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & num < rate

flag & options << started

TRUE & temp == field

0xff & done ^ started

rate + 2 * count

remember would refer back not seen

  kettle =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

january = 6;
october = 4;
june = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & mask | state

num + RATE - offset

state & started || flag

rate + RATE < resource

NUM * num & flags

remember would refer back not seen

  january =     ____    __    __

  fence =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

heart = 4;
lung = 9;
saddle = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT + count << error

2 + offset == n

count + flags ^ done

offset + count | state

VAL < count - length

remember would refer back not seen

  saddle =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

poker = 4;
scrabble = 9;
solitaire = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + 2 || done

7 < options << flags

options << offset & options

length < offset == 7

TRUE << flags && error

remember would refer back not seen

  poker =     ____    __    __

  hair =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

plastic = 5;
dutch = 8;
english = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < mask ^ flags

temp < error | started

length < started || flag

TRUE ^ mask & error

finished | ERROR << TRUE

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  plastic =     ____    __    __

  dutch =     ____    __    __

wood = 6;
verb = 4;
noun = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started ^ error && started

TRUE | options == temp

options ^ num * length

finished | flag ^ flags

0XFF ^ num - length

remember would refer back not seen

  adjective =     ____    __    __

  verb =     ____    __    __

  wood =     ____    __    __

  noun =     ____    __    __

shirt = 4;
dress = 9;
snake = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | TRUE || error

flag || 0xff & finished

TRUE || started && finished

done || finished % 2

TRUE || rate - num

remember would refer back not seen

  trousers =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

  snake =     ____    __    __

spoon = 9;
fork = 5;
knife = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != resource || flag

error && started & bits

done && TRUE * length

done && finished - length

done && count < RATE

remember would refer back not seen

  spoon =     ____    __    __

  knife =     ____    __    __

  exterior =     ____    __    __

  fork =     ____    __    __

stream = 8;
river = 4;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && flag << length

started && resource == FIELD

count * 2 && error

TRUE && BITS ^ mask

offset * length - count

remember would refer back not seen

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

  atom =     ____    __    __

plumber = 8;
builder = 9;
painter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && flags | mask

RATE * count < n

done && error || flag

count * num << offset

rate * length == temp

remember would refer back not seen

  plumber =     ____    __    __

  builder =     ____    __    __

  string =     ____    __    __

  painter =     ____    __    __

saw = 9;
screwdriver = 5;
comb = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * error ^ done

rate * 2 | 0xff

error << done * num

count / num || started

state << count - offset

remember would refer back not seen

  comb =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

red = 5;
saddle = 8;
green = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag ^ started || finished

error && flag * num

count % 2 | flags

rate * num & options

bits | count + num

remember would refer back not seen

  red =     ____    __    __

  saddle =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

chair = 9;
sofa = 5;
table = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * temp == 7

n < rate + count

2 - mask ^ state

offset * length < resource

bits & offset < COUNT

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  exterior =     ____    __    __

germany = 9;
sweden = 4;
membrane = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && flag + num

TRUE ^ flag << state

field == resource || started

started & flag << rate

N == TRUE | state

remember would refer back not seen

  sweden =     ____    __    __

  membrane =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

jupiter = 8;
venus = 9;
chapter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && finished ^ state

2 < temp || error

temp == n < count

finished | error || finished

FIELD < offset * length

remember would refer back not seen

  venus =     ____    __    __

  chapter =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

cow = 4;
hair = 5;
sheep = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || finished << done

bits | state < 7

started && options << 0xff

offset < n | options

TRUE & mask || done

remember would refer back not seen

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  hair =     ____    __    __

pencil = 8;
fly = 6;
bee = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff << done || finished

done && finished & TRUE

length << COUNT * LENGTH

count - offset < temp

TRUE && finished < 2

remember would refer back not seen

  pencil =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

blackbird = 8;
robin = 5;
fence = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << finished && TRUE

NUM - TRUE || started

mask | state % num

COUNT - 2 * offset

finished & error | STARTED

remember would refer back not seen

  sparrow =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  fence =     ____    __    __

pear = 6;
lizard = 5;
apple = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag << flags ^ 0xff

error || count * num

7 == flag << rate

options | started && TRUE

options << finished + rate

remember would refer back not seen

  apple =     ____    __    __

  pear =     ____    __    __

  lizard =     ____    __    __

  banana =     ____    __    __

hour = 6;
second = 4;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && started || STARTED

COUNT << 0xff == n

temp == started && finished

flags | OPTIONS & TRUE

rate << 7 < 2

remember would refer back not seen

  second =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

  occult =     ____    __    __

elm = 8;
oak = 6;
chestnut = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate < flags & state

TRUE ^ error && flag

rate * num << offset

started & flags && error

num - error && TRUE

remember would refer back not seen

  elm =     ____    __    __

  pencil =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

june = 5;
october = 8;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ length * num

bits ^ VAL == n

state << flag | bits

field == resource + length

TRUE ^ flag | started

remember would refer back not seen

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

  kettle =     ____    __    __

lung = 5;
liver = 8;
room = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FINISHED || TRUE & bits

num % done || flag

7 < done && error

TRUE & offset + num

DONE || started | bits

remember would refer back not seen

  room =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

scrabble = 5;
solitaire = 9;
report = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits | flags ^ finished

n == done ^ FINISHED

count - STATE | finished

rate - length << options

num - LENGTH == temp

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  report =     ____    __    __

  solitaire =     ____    __    __

dutch = 9;
mandarin = 6;
english = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && TRUE | flag

0xff | mask << count

ERROR || finished < num

num << flag & options

2 < error << done

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  tangent =     ____    __    __

  dutch =     ____    __    __

noun = 5;
adjective = 4;
grass = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & finished ^ FLAG

rate * offset + count

error || TRUE + offset

TRUE && n == 7

offset < temp == resource

remember would refer back not seen

  adjective =     ____    __    __

  grass =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

shirt = 4;
plastic = 8;
trousers = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * offset && started

done ^ resource < n

finished || flag && finished

2 * TRUE ^ error

options & 0xff == temp

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

  plastic =     ____    __    __

spoon = 8;
atom = 5;
fork = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ done & 0xff

resource == mask & flag

bits ^ NUM + offset

flag & count * offset

MASK | TRUE == 7

remember would refer back not seen

  knife =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

  atom =     ____    __    __

stream = 5;
canal = 9;
river = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == 7 * LENGTH

error || 0xff ^ bits

offset - num + NUM

offset - length & done

started || finished == temp

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  propeller =     ____    __    __

plumber = 8;
builder = 5;
painter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & flags && done

state & mask * count

mask & 2 + length

done & n < resource

flag & 0xff << flags

remember would refer back not seen

  painter =     ____    __    __

  petrol =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

screwdriver = 4;
tail = 5;
saw = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & STATE == resource

bits & error ^ FINISHED

num - OFFSET * num

flags & flag | options

rate - count + num

remember would refer back not seen

  saw =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  tail =     ____    __    __

green = 9;
blue = 5;
plastic = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & started || done

OFFSET - 7 < resource

count / TRUE & flag

length - 0xff << TRUE

count - 2 == temp

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  plastic =     ____    __    __

  red =     ____    __    __

sofa = 9;
exterior = 4;
chair = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - offset ^ mask

2 - mask | FINISHED

resource < rate + count

num - flag || done

temp < LENGTH << 0xff

remember would refer back not seen

  chair =     ____    __    __

  exterior =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

sweden = 9;
kettle = 5;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << length & TRUE

resource < field == resource

offset << flag && ERROR

7 < STATE ^ flag

num < rate | state

remember would refer back not seen

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

  kettle =     ____    __    __

mars = 8;
jupiter = 9;
venus = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < TRUE || flag

val == 7 & mask

flag && TRUE & 0XFF

done ^ bits << done

RESOURCE == started && FLAG

remember would refer back not seen

  mars =     ____    __    __

  wax =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

membrane = 4;
cow = 8;
sheep = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && STARTED * count

state ^ temp == 7

resource == n * offset

error && TRUE + NUM

error ^ bits | flags

remember would refer back not seen

  pig =     ____    __    __

  membrane =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

fly = 4;
fence = 6;
wasp = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == val + 2

FLAG && flag < num

started ^ flag || FINISHED

TRUE && done << started

TRUE | bits & flags

remember would refer back not seen

  fence =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

robin = 9;
sparrow = 5;
propeller = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FINISHED && done == val

started | done && flag

finished && flags ^ started

done | rate * 2

finished && error | flags

remember would refer back not seen

  sparrow =     ____    __    __

  propeller =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

banana = 8;
pear = 5;
grass = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || done ^ flag

TRUE | OPTIONS + num

STARTED && error || started

TRUE || flag | bits

flags | 0xff < offset

remember would refer back not seen

  grass =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

hour = 8;
string = 5;
second = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished | num << state

count * finished && done

2 * rate + num

rate * count < 2

num * count << state

remember would refer back not seen

  hour =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  string =     ____    __    __

tangent = 6;
elm = 8;
chestnut = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * num == 7

NUM * finished ^ mask

num * bits | error

RATE << TRUE % 2

count * done || finished

remember would refer back not seen

  chestnut =     ____    __    __

  oak =     ____    __    __

  tangent =     ____    __    __

  elm =     ____    __    __

june = 4;
comb = 9;
october = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << 2 + offset

offset - 2 & error

flag << rate < 2

length - offset && done

state << field == 7

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  comb =     ____    __    __

  october =     ____    __    __

heart = 8;
lung = 6;
liver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << state ^ TRUE

finished << mask | bits

FINISHED << TRUE || error

7 == resource < offset

num < done & TRUE

remember would refer back not seen

  heart =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  lizard =     ____    __    __

room = 5;
poker = 4;
scrabble = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == flags << state

2 < rate && finished

temp == 7 ^ FINISHED

rate < offset * count

n == val | TRUE

remember would refer back not seen

  scrabble =     ____    __    __

  poker =     ____    __    __

  room =     ____    __    __

  solitaire =     ____    __    __

dutch = 6;
occult = 8;
mandarin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == started || error

started ^ flag & 0xff

bits ^ error && TRUE

flag | options == val

finished ^ bits * num

remember would refer back not seen

  mandarin =     ____    __    __

  english =     ____    __    __

  occult =     ____    __    __

  dutch =     ____    __    __

saddle = 4;
noun = 5;
adjective = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished | done ^ started

flags ^ bits + 2

error | ERROR || flag

FLAG ^ OPTIONS < COUNT

error || flag & bits

remember would refer back not seen

  verb =     ____    __    __

  saddle =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

dress = 6;
trousers = 9;
shirt = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || started && TRUE

flag || length * num

flag || rate + offset

FLAG || TRUE < resource

error || count << finished

remember would refer back not seen

  dress =     ____    __    __

  shirt =     ____    __    __

  pencil =     ____    __    __

  trousers =     ____    __    __

knife = 4;
spoon = 6;
fork = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & done && TRUE

TRUE & flag * length

bits & started + rate

FINISHED & done < 2

error & done << bits

remember would refer back not seen

  atom =     ____    __    __

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

river = 4;
canal = 8;
stream = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FINISHED & OPTIONS == val

done & finished ^ TRUE

num - rate % num

0XFF & flags | flag

2 - count + 2

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  wood =     ____    __    __

petrol = 4;
painter = 6;
builder = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & TRUE || FINISHED

COUNT - 7 < num

2 * length & MASK

COUNT - 2 << mask

OFFSET - 2 == FIELD

remember would refer back not seen

  builder =     ____    __    __

  petrol =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

saw = 5;
hammer = 9;
tail = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - offset ^ error

LENGTH - TRUE | started

val < count + num

2 - TRUE || done

temp < field << 2

remember would refer back not seen

  screwdriver =     ____    __    __

  tail =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

red = 8;
blue = 9;
wheel = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

LENGTH * count ^ TRUE

offset * error | finished

finished && error != 7

val != started & finished

offset * rate << started

remember would refer back not seen

  red =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  wheel =     ____    __    __

report = 8;
sofa = 9;
chair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options ^ state | started

flags & resource != temp

TRUE || done - NUM

temp != resource << num

done & 7 < val

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  report =     ____    __    __

  table =     ____    __    __

engine = 5;
germany = 8;
france = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 / flag || finished

TRUE | ERROR & state

ERROR ^ TRUE && finished

bits & 0xff | finished

done ^ DONE || finished

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  engine =     ____    __    __

  germany =     ____    __    __

mars = 6;
venus = 5;
jupiter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < 2 - count

2 - TRUE ^ flags

num * val < NUM

finished ^ num * 2

done && flag % count

remember would refer back not seen

  plastic =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

exterior = 8;
cow = 6;
pig = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << length % rate

field != n && finished

error || done != val

num < done || TRUE

options << TRUE || started

remember would refer back not seen

  sheep =     ____    __    __

  exterior =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

bee = 6;
wasp = 5;
fly = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * rate - count

finished ^ flags - 2

num < 7 && TRUE

options & TRUE && done

started & length * offset

remember would refer back not seen

  fly =     ____    __    __

  wasp =     ____    __    __

  plastic =     ____    __    __

  bee =     ____    __    __

sparrow = 8;
blackbird = 4;
occult = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num - bits | done

num * bits & state

field != temp < field

options & offset << options

ERROR || finished && started

remember would refer back not seen

  occult =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

apple = 5;
banana = 8;
atom = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != n | state

finished | FINISHED || STARTED

state | done << rate

flags | error != resource

done || MASK | TRUE

remember would refer back not seen

  banana =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  atom =     ____    __    __

second = 6;
hour = 9;
minute = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || flag << done

rate * OFFSET != n

count << temp != n

done & num - offset

done && flag - offset

remember would refer back not seen

  wood =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

elm = 9;
snake = 8;
chestnut = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | length * count

started & finished ^ done

done << finished | FLAGS

length - val != resource

TRUE | finished < temp

remember would refer back not seen

  oak =     ____    __    __

  snake =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

june = 5;
pencil = 6;
january = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && 2 << rate

flags ^ flag < 2

2 < state & 0xff

offset - 2 * num

field != length - rate

remember would refer back not seen

  january =     ____    __    __

  pencil =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

liver = 5;
chapter = 6;
lung = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || 0xff & finished

error && FINISHED | state

started << TRUE - num

resource < length | state

val != 2 * num

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

  chapter =     ____    __    __

poker = 5;
solitaire = 9;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag << mask ^ STARTED

FLAG ^ n != 7

done && finished ^ flag

length < RESOURCE != 7

field != TRUE || FINISHED

remember would refer back not seen

  propeller =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

dutch = 8;
english = 6;
mandarin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count - flag && done

n < val << flag

2 / count && flag

2 - offset << flags

TRUE && resource < LENGTH

remember would refer back not seen

  english =     ____    __    __

  tangent =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

occult = 5;
adjective = 8;
noun = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < num / offset

FLAG ^ 0xff & flag

started || TRUE * num

state ^ flags << flag

finished || done < temp

remember would refer back not seen

  noun =     ____    __    __

  occult =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

fence = 6;
dress = 8;
trousers = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options | flag ^ bits

TRUE && error || flag

length << n < 2

num - mask & 0XFF

temp != n ^ options

remember would refer back not seen

  fence =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

fork = 4;
knife = 9;
comb = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && STARTED & flags

state & TRUE || DONE

length - rate < num

error | flag && TRUE

flag | error - count

remember would refer back not seen

  comb =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

canal = 5;
river = 4;
tail = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < 2 ^ flags

done || finished ^ error

mask << state & done

finished << flag && error

rate - COUNT || flag

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  tail =     ____    __    __

  stream =     ____    __    __

plumber = 8;
plastic = 9;
painter = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && TRUE != temp

started && error & TRUE

error && count * rate

done && 2 - count

TRUE && offset < temp

remember would refer back not seen

  plastic =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

wheel = 8;
saw = 4;
hammer = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && STARTED << COUNT

done && started ^ error

rate * length && started

FLAG && flag | done

count * 2 - length

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  wheel =     ____    __    __

  hammer =     ____    __    __

blue = 8;
engine = 6;
green = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && flag || started

count * rate < TEMP

0xff & error != temp

num * offset << flags

2 * flags ^ mask

remember would refer back not seen

  red =     ____    __    __

  engine =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

table = 5;
comb = 4;
sofa = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * flag | finished

offset % 2 || flag

num << offset - rate

count - rate != VAL

state << num < n

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  comb =     ____    __    __

germany = 4;
tangent = 5;
sweden = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num - 2 & started

2 << 0xff ^ options

2 - flag && error

length << mask | bits

offset << flag || TRUE

remember would refer back not seen

  tangent =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

jupiter = 5;
wax = 9;
mars = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < temp != field

count < options & flags

val != n & 0xff

started ^ offset << num

n < field && error

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  wax =     ____    __    __

  mars =     ____    __    __

sheep = 8;
pig = 4;
cow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != field && flag

ERROR ^ OPTIONS | mask

count < FIELD % rate

resource != rate * COUNT

done ^ error || flag

remember would refer back not seen

  report =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

fly = 9;
bee = 8;
membrane = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < rate - num

temp != offset - num

mask | done != n

field != 7 < length

TRUE | flags & bits

remember would refer back not seen

  bee =     ____    __    __

  membrane =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

blackbird = 6;
robin = 5;
sparrow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != temp << num

flag | FLAG && error

7 != resource ^ error

error | bits % num

temp != val | flags

remember would refer back not seen

  blackbird =     ____    __    __

  robin =     ____    __    __

  exterior =     ____    __    __

  sparrow =     ____    __    __

chapter = 9;
apple = 6;
banana = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || finished | mask

0xff | rate - offset

TEMP != val || error

mask | started < 2

TRUE | started << 0XFF

remember would refer back not seen

  apple =     ____    __    __

  pear =     ____    __    __

  chapter =     ____    __    __

  banana =     ____    __    __

second = 6;
minute = 8;
hour = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK & TRUE && flag

options & offset * 2

started & error - 2

done & resource < temp

mask & state << rate

remember would refer back not seen

  minute =     ____    __    __

  hour =     ____    __    __

  occult =     ____    __    __

  second =     ____    __    __

chestnut = 4;
propeller = 6;
elm = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & FLAG ^ flag

done & bits | done

2 - rate * num

done & flag || TRUE

offset - num < resource

remember would refer back not seen

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

  propeller =     ____    __    __

january = 5;
october = 6;
june = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * field != val

rate - length << bits

offset * length & started

offset - error ^ flags

2 - state | 0xff

remember would refer back not seen

  june =     ____    __    __

  october =     ____    __    __

  january =     ____    __    __

  hair =     ____    __    __

heart = 5;
liver = 6;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset - length || error

rate << field != RESOURCE

resource < length << error

length << done & TRUE

temp < flags ^ mask

remember would refer back not seen

  occult =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

solitaire = 6;
scrabble = 4;
poker = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << TRUE && ERROR

length < temp | flags

0xff << 2 * rate

num < error || started

started ^ options != resource

remember would refer back not seen

  scrabble =     ____    __    __

  lizard =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

mandarin = 6;
english = 4;
dutch = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ flag & finished

flags ^ finished && started

bits | 0xff ^ started

bits ^ DONE * offset

TRUE | state || started

remember would refer back not seen

  dutch =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  kettle =     ____    __    __

verb = 5;
noun = 8;
adjective = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ count - rate

error || field != temp

state ^ field < rate

DONE || options & started

error || flag && finished

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

  tail =     ____    __    __

trousers = 5;
room = 4;
shirt = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || done * count

done || finished - num

FINISHED || 2 < val

flag || num << OFFSET

error || done ^ state

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  room =     ____    __    __

  trousers =     ____    __    __

fork = 5;
knife = 8;
saddle = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && flag != n

finished && done & error

started && count * rate

TRUE && started - 2

started && num < 7

remember would refer back not seen

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

  saddle =     ____    __    __

canal = 8;
fence = 6;
river = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && bits << mask

flag && done ^ options

length * rate && flag

done && flag | mask

count * LENGTH - RATE

remember would refer back not seen

  river =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  fence =     ____    __    __

painter = 9;
plumber = 6;
plastic = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && finished || error

RATE * 2 < field

0XFF & TRUE != n

length * offset << BITS

offset * state ^ finished

remember would refer back not seen

  painter =     ____    __    __

  plumber =     ____    __    __

  plastic =     ____    __    __

  builder =     ____    __    __

hammer = 8;
screwdriver = 4;
wheel = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * FLAGS | bits

rate * num || finished

0xff << error - offset

2 - count != resource

offset << rate < num

remember would refer back not seen

  wheel =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

engine = 5;
green = 9;
red = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG && n == field

2 * 0xff | TRUE

DONE << field == temp

2 + flag && done

flag ^ bits | error

remember would refer back not seen

  green =     ____    __    __

  red =     ____    __    __

  engine =     ____    __    __

  blue =     ____    __    __

chair = 8;
sofa = 6;
table = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < finished || error

field == rate + length

OPTIONS & finished && started

finished | 2 * OFFSET

7 == DONE & flags

remember would refer back not seen

  occult =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

germany = 4;
france = 9;
lizard = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started << done || finished

rate < flags ^ mask

rate * flag || TRUE

finished & done || error

resource == n < num

remember would refer back not seen

  lizard =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

mars = 4;
venus = 8;
jupiter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE << rate && TRUE

num + rate & finished

TRUE && finished < resource

bits & 7 < val

error & length << state

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  pencil =     ____    __    __

sheep = 4;
pig = 6;
wood = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & bits + count

flag ^ mask & flags

2 * STARTED ^ flag

done || finished << error

rate < field == n

remember would refer back not seen

  wood =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

wasp = 6;
bee = 8;
grass = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ error && FLAG

TRUE || ERROR | started

ERROR && error ^ state

num + rate << offset

resource == temp | mask

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  grass =     ____    __    __

  bee =     ____    __    __

robin = 9;
fence = 8;
sparrow = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff | mask || error

7 == val << started

done || temp == n

FINISHED << 0xff | FINISHED

offset < flag && finished

remember would refer back not seen

  fence =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

pear = 4;
banana = 9;
membrane = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && TRUE << rate

done & resource == 7

flags << OPTIONS ^ 0xff

bits ^ 7 == n

finished || error + rate

remember would refer back not seen

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

  membrane =     ____    __    __

second = 5;
hour = 4;
propeller = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << count + rate

TEMP == length * 2

state | TRUE ^ started

temp == TRUE && finished

count << 7 < resource

remember would refer back not seen

  minute =     ____    __    __

  propeller =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

chestnut = 4;
exterior = 5;
elm = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + count / rate

2 + resource == temp

rate * num + 2

TRUE << options & state

flag & TRUE * num

remember would refer back not seen

  chestnut =     ____    __    __

  oak =     ____    __    __

  exterior =     ____    __    __

  elm =     ____    __    __

wheel = 5;
january = 8;
june = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < num << started

FLAG && count * 2

bits | rate < length

done || options & 0xff

rate % 2 < val

remember would refer back not seen

  january =     ____    __    __

  wheel =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

liver = 8;
heart = 4;
lung = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * offset && finished

val < count & flags

temp == VAL || ERROR

offset / rate << finished

FINISHED && TRUE || started

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  room =     ____    __    __

  heart =     ____    __    __

solitaire = 4;
hair = 5;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || flag < temp

error | count + length

TRUE | mask & bits

num / 7 == temp

flag || mask ^ error

remember would refer back not seen

  scrabble =     ____    __    __

  poker =     ____    __    __

  hair =     ____    __    __

  solitaire =     ____    __    __

english = 6;
mandarin = 9;
string = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET << LENGTH * offset

finished && started | flags

num < 0xff | error

7 == bits ^ flags

state ^ bits << 0XFF

remember would refer back not seen

  string =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

wax = 9;
noun = 4;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + temp < val

flag | options << started

error || started * count

FINISHED | state && finished

length * ERROR & FLAG

remember would refer back not seen

  adjective =     ____    __    __

  wax =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

petrol = 9;
trousers = 5;
dress = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + count | bits

TRUE && COUNT + 2

done ^ error < OFFSET

flag ^ length + num

started | 7 == field

remember would refer back not seen

  dress =     ____    __    __

  petrol =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

spoon = 6;
comb = 5;
fork = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ error || started

2 + offset || finished

FINISHED & TRUE ^ finished

options ^ 0xff % count

field < 2 * count

remember would refer back not seen

  fork =     ____    __    __

  comb =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

canal = 4;
chapter = 8;
river = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < resource + 2

length + count ^ flag

finished & done | TRUE

FLAG && bits & flags

flag || TRUE && flag

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  chapter =     ____    __    __

builder = 4;
plumber = 5;
wheel = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & started && TRUE

state & length % rate

state & num + count

done & options < temp

finished & OPTIONS << count

remember would refer back not seen

  builder =     ____    __    __

  wheel =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

hammer = 8;
screwdriver = 9;
propeller = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & temp == field

flag & state ^ bits

rate + num * count

started & mask | finished

LENGTH + num < 7

remember would refer back not seen

  propeller =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

green = 4;
blue = 6;
membrane = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & STATE || DONE

count + rate << 0xff

num / 2 & error

num + offset == temp

offset + STARTED ^ finished

remember would refer back not seen

  membrane =     ____    __    __

  red =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

exterior = 6;
sofa = 4;
chair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + 2 | TRUE

count + started || done

val < 0xff << rate

FINISHED << error & flags

OFFSET < 7 == resource

remember would refer back not seen

  sofa =     ____    __    __

  exterior =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

germany = 5;
france = 4;
petrol = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options << TRUE && done

RESOURCE < finished ^ done

rate << count * num

val < COUNT | options

count < TRUE || flag

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  petrol =     ____    __    __

  germany =     ____    __    __

venus = 8;
mars = 6;
jupiter = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == bits & flags

FIELD == error && finished

error && finished & options

started ^ bits == N

field == num / length

remember would refer back not seen

  mars =     ____    __    __

  tail =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

sheep = 9;
pig = 4;
plastic = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && length * offset

DONE ^ flag | TRUE

7 == 2 + length

ERROR && offset + 2

started ^ mask || started

remember would refer back not seen

  plastic =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

fly = 8;
bee = 9;
wasp = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == count < field

TRUE && flag < length

mask | error & done

TRUE && error << num

started | state && flag

remember would refer back not seen

  wasp =     ____    __    __

  atom =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

blackbird = 8;
snake = 5;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && error == RESOURCE

state | options / rate

flag && mask ^ error

options | TRUE + rate

flag && started | finished

remember would refer back not seen

  snake =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

pear = 6;
banana = 5;
pencil = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || TRUE | done

0xff | done < val

TRUE && flag || finished

state | 0xff << state

flag | val == 7

remember would refer back not seen

  pear =     ____    __    __

  apple =     ____    __    __

  pencil =     ____    __    __

  banana =     ____    __    __

second = 6;
minute = 5;
wood = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * error && flag

num * rate + count

length / NUM < rate

2 / num << mask

OFFSET * temp == resource

remember would refer back not seen

  hour =     ____    __    __

  minute =     ____    __    __

  wood =     ____    __    __

  second =     ____    __    __

chestnut = 8;
report = 4;
elm = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * 2 ^ error

length * mask | OPTIONS

state << length + count

offset * done || finished

mask << num < temp

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  report =     ____    __    __

june = 8;
october = 9;
january = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + state & finished

error << done == n

NUM + length && started

started << 0xff ^ mask

count << error | bits

remember would refer back not seen

  october =     ____    __    __

  january =     ____    __    __

  fence =     ____    __    __

  june =     ____    __    __

hot = 6;
lung = 5;
liver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error << flag || TRUE

VAL < STATE & flags

n == resource << TRUE

FIELD < count && TRUE

temp == resource ^ started

remember would refer back not seen

  heart =     ____    __    __

  lung =     ____    __    __

  hot =     ____    __    __

  liver =     ____    __    __

solitaire = 4;
poker = 6;
scrabble = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < rate * length

temp == resource | finished

temp < 2 + rate

val == 7 || TRUE

options ^ flag & mask

remember would refer back not seen

  room =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

english = 8;
dutch = 6;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ bits && TRUE

state ^ options * offset

TRUE | started ^ 0XFF

done ^ bits + rate

done | 0xff || TRUE

remember would refer back not seen

  english =     ____    __    __

  mandarin =     ____    __    __

  occult =     ____    __    __

  dutch =     ____    __    __

adjective = 8;
noun = 4;
verb = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options ^ 7 < length

started || TRUE & flag

TRUE ^ OPTIONS << finished

flag || error && TRUE

ERROR || TRUE * rate

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  pencil =     ____    __    __

  verb =     ____    __    __

shirt = 8;
engine = 9;
dress = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || rate + offset

flag || count < offset

finished || flag << finished

error || field == n

error || TRUE ^ options

remember would refer back not seen

  dress =     ____    __    __

  shirt =     ____    __    __

  engine =     ____    __    __

  trousers =     ____    __    __

string = 5;
knife = 4;
spoon = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & started && finished

flags & num * 2

ERROR & flag + 2

started & flags < rate

started & bits << RATE

remember would refer back not seen

  fork =     ____    __    __

  string =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

kettle = 8;
river = 6;
stream = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & TRUE == n

mask & done ^ options

count + 2 * rate

done & flags | bits

offset + TEMP < val

remember would refer back not seen

  kettle =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

wheel = 5;
builder = 4;
painter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & 0XFF || error

count + rate << 2

2 % finished & mask

length + rate == RESOURCE

num + length ^ done

remember would refer back not seen

  painter =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

  wheel =     ____    __    __

saw = 8;
hammer = 4;
propeller = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + num | state

count + done || started

n < rate << 0xff

done << options & TRUE

n < field == VAL

remember would refer back not seen

  propeller =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

green = 4;
red = 9;
wax = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits << finished ^ TRUE

count - temp == n

bits << options & STATE

MASK | resource == field

num / TRUE || finished

remember would refer back not seen

  wax =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

occult = 4;
sofa = 6;
chair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset % length << options

state & 0xff < 7

STARTED && flags ^ options

flags | offset / 2

count * length + num

remember would refer back not seen

  occult =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

sweden = 5;
france = 9;
germany = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < field + count

mask & done || started

length - count << mask

TRUE ^ finished || done

finished | started & flag

remember would refer back not seen

  pencil =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

venus = 4;
tangent = 9;
jupiter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == field * length

temp < DONE | 0xff

2 - offset && TRUE

started ^ offset + 2

temp == FLAG << offset

remember would refer back not seen

  mars =     ____    __    __

  tangent =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

pig = 5;
lizard = 8;
cow = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & OPTIONS ^ 0xff

temp < 2 && TRUE

options & length + count

flag || mask << 2

length - count * 2

remember would refer back not seen

  sheep =     ____    __    __

  lizard =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

wasp = 9;
fly = 4;
bee = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | done || TRUE

length * count | error

TRUE && started || FLAG

flag | temp < val

bits & flag * num

remember would refer back not seen

  bee =     ____    __    __

  fly =     ____    __    __

  wheel =     ____    __    __

  wasp =     ____    __    __

sparrow = 8;
blackbird = 9;
robin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE << FLAG && started

flag | flags << 0xff

mask ^ num * offset

offset - length + 2

resource == n && flag

remember would refer back not seen

  robin =     ____    __    __

  wood =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

banana = 8;
grass = 9;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && error & flags

val == started || finished

2 < num * 2

count * options ^ FLAGS

flags ^ TRUE < count

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  grass =     ____    __    __

  pear =     ____    __    __

minute = 5;
hour = 9;
second = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OPTIONS & flags << flag

started || OPTIONS & flag

offset - flags & TRUE

flag && offset + 2

n == resource < val

remember would refer back not seen

  second =     ____    __    __

  saddle =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

elm = 6;
oak = 4;
membrane = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & 0xff && started

LENGTH < resource || finished

finished || TRUE && started

TRUE && flag << finished

resource < n << TRUE

remember would refer back not seen

  oak =     ____    __    __

  chestnut =     ____    __    __

  membrane =     ____    __    __

  elm =     ____    __    __

snake = 9;
june = 6;
january = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & 0xff | flag

options | done ^ state

count << rate + length

2 - length < rate

TRUE && offset * rate

remember would refer back not seen

  october =     ____    __    __

  snake =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

liver = 8;
lung = 9;
room = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask << val == 7

started && finished == temp

done ^ started << 2

num * rate == VAL

options ^ finished == val

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  room =     ____    __    __

  lung =     ____    __    __

string = 5;
solitaire = 4;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * error && finished

error || field == resource

done ^ error | flags

count < length ^ finished

rate < n == 7

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  string =     ____    __    __

  solitaire =     ____    __    __

hot = 5;
dutch = 9;
english = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error << bits | started

rate << error || FINISHED

2 - started | bits

FLAG && started < num

finished || rate % num

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

  hot =     ____    __    __

plastic = 5;
adjective = 6;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == finished | started

offset < 7 & flags

flag && options | started

length << rate * offset

flag | started && done

remember would refer back not seen

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  plastic =     ____    __    __

trousers = 5;
dress = 8;
shirt = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate % num & 0xff

options ^ finished && TRUE

temp == rate + OFFSET

COUNT - done || TRUE

mask & resource == temp

remember would refer back not seen

  pencil =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

knife = 5;
fork = 9;
hair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || TRUE < field

rate - bits ^ state

val == error & TRUE

error || state ^ bits

flags << offset < num

remember would refer back not seen

  knife =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

  hair =     ____    __    __

canal = 6;
occult = 8;
stream = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ 0xff & started

COUNT / 2 < count

started || TRUE | flags

mask | count + offset

done || STARTED + count

remember would refer back not seen

  river =     ____    __    __

  occult =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

atom = 4;
painter = 5;
plumber = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & TRUE && flag

TRUE & finished * 2

bits & TRUE + rate

bits & field < count

0xff & num << flags

remember would refer back not seen

  atom =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

saw = 9;
hammer = 5;
screwdriver = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & state == temp

flag & done ^ bits

length - rate * length

options & finished | state

length - offset + num

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  room =     ____    __    __

  hammer =     ____    __    __

tail = 5;
red = 9;
green = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0XFF & started || TRUE

2 - num < rate

count * options & 0xff

offset - count << 2

count - 7 == temp

remember would refer back not seen

  tail =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

sofa = 6;
table = 4;
chair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - MASK ^ error

2 - num | mask

length < offset + length

offset - count || DONE

field < count << 0xff

remember would refer back not seen

  snake =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

hot = 8;
germany = 9;
france = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished << OFFSET & bits

resource < VAL == 7

num << error && finished

7 < MASK ^ finished

length < n | STARTED

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  hot =     ____    __    __

  sweden =     ____    __    __

venus = 8;
jupiter = 5;
chapter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < count || done

n == TRUE & done

flag && started & mask

0XFF ^ finished << length

7 == TRUE && done

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  chapter =     ____    __    __

  mars =     ____    __    __

pig = 9;
wheel = 8;
sheep = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && count * num

options ^ temp == field

resource == rate * offset

flag && LENGTH + rate

finished ^ FLAGS | started

remember would refer back not seen

  cow =     ____    __    __

  wheel =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

fly = 4;
wasp = 5;
bee = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == temp + offset

done && field < offset

done ^ started || ERROR

done && error << offset

ERROR | STARTED & bits

remember would refer back not seen

  propeller =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

sparrow = 5;
wood = 8;
robin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && 7 == resource

TRUE | STATE && done

TRUE && 0xff ^ state

OPTIONS | 2 * offset

done && flags | flag

remember would refer back not seen

  blackbird =     ____    __    __

  wood =     ____    __    __

  robin =     ____    __    __

  sparrow =     ____    __    __

exterior = 5;
pear = 9;
banana = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || TRUE ^ mask

TRUE | offset + rate

started && finished || done

TRUE || started | STATE

flag | field < resource

remember would refer back not seen

  exterior =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

second = 6;
hour = 8;
comb = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | error << rate

num * rate && DONE

count * offset + rate

num * rate < num

rate * options << error

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  comb =     ____    __    __

  hour =     ____    __    __

membrane = 4;
elm = 5;
chestnut = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * rate == resource

length * started ^ bits

num * count | finished

finished << count * rate

offset * started || flag

remember would refer back not seen

  elm =     ____    __    __

  membrane =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

january = 9;
june = 8;
saddle = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag << error + offset

offset - done & options

finished << n < NUM

count - error && finished

bits << started == 7

remember would refer back not seen

  october =     ____    __    __

  saddle =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

pencil = 6;
liver = 4;
heart = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << 0xff ^ flags

offset << flags | options

2 << error || TRUE

field == resource < val

7 < offset & mask

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  pencil =     ____    __    __

  heart =     ____    __    __

tangent = 8;
solitaire = 5;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == bits << flags

2 < val && STARTED

7 == val ^ state

n < LENGTH * count

field == 0xff | TRUE

remember would refer back not seen

  poker =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  tangent =     ____    __    __

dutch = 4;
mandarin = 5;
english = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == n || done

started ^ flag & options

flags ^ started && finished

finished | 0xff == field

started ^ bits * count

remember would refer back not seen

  english =     ____    __    __

  hair =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

verb = 9;
noun = 6;
adjective = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished | TRUE ^ error

bits ^ OPTIONS + 2

0xff | bits || finished

FINISHED ^ rate < length

TRUE || finished & 0xff

remember would refer back not seen

  noun =     ____    __    __

  verb =     ____    __    __

  pencil =     ____    __    __

  adjective =     ____    __    __

trousers = 6;
dress = 8;
shirt = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || error && ERROR

error || TRUE * rate

done || error + rate

finished || field < count

flag || 2 << STATE

remember would refer back not seen

  occult =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

spoon = 9;
knife = 6;
fork = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & flag && error

TRUE & options / num

mask & 2 + count

TRUE & offset < temp

finished & started << mask

remember would refer back not seen

  report =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

plastic = 9;
stream = 6;
river = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & mask == resource

finished & state ^ options

offset - count * rate

0xff & bits | 0xff

offset - length + offset

remember would refer back not seen

  canal =     ____    __    __

  plastic =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

builder = 8;
plumber = 9;
atom = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & FINISHED || TRUE

rate - offset < resource

offset * DONE & finished

LENGTH - options << finished

length - resource == temp

remember would refer back not seen

  atom =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

screwdriver = 8;
room = 6;
saw = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count - num ^ options

COUNT - started | mask

2 < 7 + offset

2 - count || done

count < offset << LENGTH

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

  room =     ____    __    __

red = 5;
blue = 4;
hot = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + error && done

temp != 7 << RATE

TRUE | started && finished

n != field & error

mask << bits ^ mask

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  hot =     ____    __    __

  red =     ____    __    __

chair = 4;
sofa = 5;
plastic = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | FLAGS || finished

flag | resource < val

flag && temp == N

ERROR & resource == 7

mask << length + OFFSET

remember would refer back not seen

  sofa =     ____    __    __

  table =     ____    __    __

  plastic =     ____    __    __

  chair =     ____    __    __

string = 8;
germany = 4;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & state | flag

error && bits | TRUE

0XFF ^ finished == field

state << num < field

resource != flags ^ 0xff

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  string =     ____    __    __

  germany =     ____    __    __

mars = 5;
jupiter = 8;
fence = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & flags ^ TRUE

field != rate + offset

done | TRUE & error

rate + TRUE || FLAG

num < rate && error

remember would refer back not seen

  fence =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

wheel = 4;
pig = 5;
sheep = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate / count || flag

flag & STATE << count

count * COUNT + 2

done ^ ERROR & state

n != field < rate

remember would refer back not seen

  pig =     ____    __    __

  wheel =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

fly = 9;
bee = 6;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource != flags | state

TRUE | finished << flag

rate < flags << num

started || flag && started

options ^ DONE || FLAG

remember would refer back not seen

  wasp =     ____    __    __

  occult =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

robin = 9;
report = 4;
sparrow = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 / flags << NUM

length << rate % num

TRUE | state == temp

offset + rate | state

started || finished | 0xff

remember would refer back not seen

  sparrow =     ____    __    __

  report =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

pencil = 5;
pear = 4;
banana = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * length && finished

0XFF & 2 + count

TRUE || state & started

done && error << rate

done ^ TRUE && flag

remember would refer back not seen

  pencil =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

second = 8;
snake = 6;
minute = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && DONE < num

offset * rate == resource

TRUE || field < N

NUM + rate * count

7 != TRUE && finished

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  snake =     ____    __    __

oak = 5;
chestnut = 9;
elm = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && count * length

temp != n == val

temp != 7 || flag

TRUE ^ bits << state

count + num < val

remember would refer back not seen

  grass =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

january = 9;
wood = 5;
october = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || temp == n

0xff ^ flags + num

error << options && TRUE

bits ^ BITS * length

finished || started << length

remember would refer back not seen

  june =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  wood =     ____    __    __

lung = 9;
heart = 5;
wax = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < TRUE ^ flags

offset * 0xff & TRUE

7 != num * length

TRUE | length * LENGTH

LENGTH < MASK & bits

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  heart =     ____    __    __

  wax =     ____    __    __

solitaire = 5;
poker = 9;
saddle = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & temp < resource

n < count == field

started || finished * offset

num + count & 0xff

NUM < bits | finished

remember would refer back not seen

  poker =     ____    __    __

  saddle =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

dutch = 9;
english = 4;
plastic = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & error || finished

started || done ^ options

finished & num / length

finished | state + 2

num / 2 < resource

remember would refer back not seen

  plastic =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

verb = 4;
propeller = 5;
adjective = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && FINISHED + length

started & error && done

started && error || TRUE

2 << flags == field

finished && state ^ finished

remember would refer back not seen

  noun =     ____    __    __

  adjective =     ____    __    __

  propeller =     ____    __    __

  verb =     ____    __    __

shirt = 8;
atom = 4;
trousers = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ options < 7

finished << done | flags

TRUE | options ^ mask

length * state ^ options

count << length || TRUE

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  atom =     ____    __    __

  dress =     ____    __    __

knife = 9;
occult = 8;
fork = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < rate * 2

offset * rate | flags

started && error & state

n < 2 + rate

flags ^ TRUE | flags

remember would refer back not seen

  fork =     ____    __    __

  occult =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

river = 4;
petrol = 6;
canal = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < 7 || flag

2 + TRUE << num

error || count + offset

2 + 0xff ^ error

count + val == resource

remember would refer back not seen

  canal =     ____    __    __

  petrol =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

chapter = 6;
plumber = 4;
painter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != val || finished

finished && error & state

started && 2 * length

started && TRUE + offset

started && finished < 7

remember would refer back not seen

  builder =     ____    __    __

  chapter =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

saw = 6;
hammer = 8;
screwdriver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && TRUE << error

ERROR && flag == resource

2 * num && finished

finished && started ^ flag

NUM * count + rate

remember would refer back not seen

  saw =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  lizard =     ____    __    __

red = 4;
green = 9;
propeller = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && flags | done

offset * rate < val

TRUE && error || started

rate * 2 << offset

RATE * val == 7

remember would refer back not seen

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

  propeller =     ____    __    __

chair = 5;
table = 8;
sofa = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * 0xff ^ error

offset % 2 | 0xff

MASK << TRUE + length

2 * TRUE || error

started << count < n

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  fence =     ____    __    __

  sofa =     ____    __    __

membrane = 9;
sweden = 4;
germany = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + STATE & done

mask << started == temp

2 + TRUE && finished

error << state ^ error

flag << finished | TRUE

remember would refer back not seen

  sweden =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

  membrane =     ____    __    __

mars = 8;
jupiter = 6;
exterior = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state << mask || flag

n < mask & flag

field != OPTIONS & 0xff

mask ^ num << bits

length < resource && finished

remember would refer back not seen

  exterior =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

cow = 4;
wheel = 5;
sheep = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != field && finished

STATE ^ resource == n

2 < offset % NUM

n != count * rate

FLAGS ^ bits | OPTIONS

remember would refer back not seen

  sheep =     ____    __    __

  cow =     ____    __    __

  wheel =     ____    __    __

  pig =     ____    __    __

fly = 9;
wasp = 5;
tail = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < 2 + rate

FIELD != 7 + 2

state ^ STARTED || flag

val != 7 < val

finished | error & finished

remember would refer back not seen

  tail =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

sparrow = 4;
robin = 9;
grass = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != options << bits

done | bits && error

temp != 7 == temp

0xff | done * rate

resource != TRUE ^ error

remember would refer back not seen

  grass =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

atom = 4;
apple = 8;
pear = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || flags ^ flag

0XFF | done + offset

RESOURCE != OPTIONS | mask

started || TRUE | state

flags | val < num

remember would refer back not seen

  atom =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

string = 9;
hour = 8;
second = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags | mask << rate

started & flag && TRUE

flags & TRUE * count

0xff & length + rate

flag & finished < resource

remember would refer back not seen

  second =     ____    __    __

  string =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

chestnut = 6;
comb = 4;
elm = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAGS & bits << 2

0xff & flag == 7

state & finished ^ TRUE

length + num % 2

state & 0xff | finished

remember would refer back not seen

  comb =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

january = 6;
october = 4;
report = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + 7 < temp

0xff & mask || TRUE

2 + offset << rate

length * FLAG & bits

2 + rate == resource

remember would refer back not seen

  june =     ____    __    __

  october =     ____    __    __

  report =     ____    __    __

  january =     ____    __    __

heart = 4;
lung = 5;
hot = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + 2 ^ state

2 + offset | done

rate + done || finished

offset < val << options

num << bits & flag

remember would refer back not seen

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

  hot =     ____    __    __

scrabble = 8;
plastic = 4;
solitaire = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < offset == field

started << offset && finished

resource < 2 ^ FINISHED

rate << 2 * OFFSET

resource < TEMP | state

remember would refer back not seen

  scrabble =     ____    __    __

  plastic =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

dutch = 8;
mandarin = 4;
plastic = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field < resource || error

bits ^ 0xff & flags

TRUE ^ DONE && flag

state | 7 == n

FLAG ^ 2 * length

remember would refer back not seen

  plastic =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

verb = 5;
noun = 9;
adjective = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | state ^ finished

done ^ NUM + rate

started | TRUE || done

mask ^ flags < offset

error || TRUE & flags

remember would refer back not seen

  pencil =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

shirt = 8;
trousers = 5;
dress = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || flag && FINISHED

finished || TRUE * count

flag || TRUE + length

started || n < resource

flag || done << flag

remember would refer back not seen

  dress =     ____    __    __

  trousers =     ____    __    __

  occult =     ____    __    __

  shirt =     ____    __    __

kettle = 4;
knife = 5;
spoon = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != 7 || done

started && done & TRUE

finished && done * LENGTH

error && TRUE + count

finished && started < temp

remember would refer back not seen

  fork =     ____    __    __

  knife =     ____    __    __

  kettle =     ____    __    __

  spoon =     ____    __    __

stream = 6;
canal = 4;
river = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

DONE && flags << mask

done && finished == 7

length % TRUE && flag

done && started ^ 0xff

length % 2 + LENGTH

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  snake =     ____    __    __

  stream =     ____    __    __

plumber = 8;
painter = 5;
chapter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && done | error

num % offset < TEMP

done && TRUE || started

length * count << started

offset * resource == n

remember would refer back not seen

  chapter =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

lizard = 4;
hammer = 8;
saw = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * mask ^ flags

rate * state | flags

length << offset + length

offset % error || flag

length << n < resource

remember would refer back not seen

  hammer =     ____    __    __

  lizard =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

red = 8;
blue = 6;
kettle = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && finished | 0xff

TRUE || finished ^ started

resource < started || error

started || error | options

error && started < rate

remember would refer back not seen

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  kettle =     ____    __    __

chair = 5;
snake = 9;
sofa = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < n ^ 0XFF

mask << val == temp

offset - num << count

STARTED & flag << 0xff

2 / count << flag

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  snake =     ____    __    __

  table =     ____    __    __

comb = 8;
germany = 9;
sweden = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length / ERROR & finished

options & mask + rate

num / count < OFFSET

rate << flag || error

started || val == n

remember would refer back not seen

  comb =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

venus = 6;
plastic = 8;
jupiter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == TRUE || finished

done && finished || flag

started | flag < count

started && done << offset

bits | options || TRUE

remember would refer back not seen

  venus =     ____    __    __

  plastic =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

occult = 5;
cow = 8;
pig = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * rate + count

count < length + rate

flag && started + length

2 << rate < field

n == bits ^ TRUE

remember would refer back not seen

  cow =     ____    __    __

  occult =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

bee = 5;
report = 9;
fly = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | error * rate

flags & TRUE && error

state << ERROR && started

error ^ OPTIONS + count

length < NUM * offset

remember would refer back not seen

  report =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

robin = 8;
sparrow = 6;
room = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK & val < length

NUM - COUNT == temp

FINISHED && field == n

finished | error << bits

error || started & FLAG

remember would refer back not seen

  room =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

banana = 4;
fence = 9;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == 7 < resource

field == n && flag

done && error * count

bits << finished & error

flag ^ flags < n

remember would refer back not seen

  apple =     ____    __    __

  pear =     ____    __    __

  fence =     ____    __    __

  banana =     ____    __    __

minute = 4;
wood = 8;
hour = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | state & mask

state | 0xff && error

error && flag ^ started

2 - length * rate

done << TRUE | error

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  wood =     ____    __    __

  hour =     ____    __    __

oak = 6;
elm = 8;
grass = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & rate * num

7 < rate == temp

COUNT * offset == 7

resource == RESOURCE | 0xff

TRUE ^ done * num

remember would refer back not seen

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

  grass =     ____    __    __

january = 8;
october = 9;
june = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == rate * offset

offset * TRUE | FLAGS

state & ERROR == field

bits ^ 0xff & done

offset - TRUE ^ bits

remember would refer back not seen

  engine =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

liver = 8;
lung = 6;
heart = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << rate + length

rate - count | mask

num - state & TRUE

options | state ^ started

rate * started && flag

remember would refer back not seen

  lung =     ____    __    __

  heart =     ____    __    __

  occult =     ____    __    __

  liver =     ____    __    __

tail = 9;
poker = 5;
solitaire = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag ^ TRUE << count

val == rate + length

started || done << 0xff

2 - offset + rate

NUM < flags | TRUE

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  tail =     ____    __    __

english = 5;
mandarin = 9;
dutch = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ TRUE || FLAG

TRUE & ERROR || error

started ^ state == resource

count < TRUE && finished

count - ERROR || started

remember would refer back not seen

  membrane =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

petrol = 8;
noun = 9;
adjective = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << TRUE ^ FLAG

error << finished * num

mask | flags + 2

7 == options << finished

count * offset ^ done

remember would refer back not seen

  noun =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

  petrol =     ____    __    __

shirt = 9;
trousers = 8;
saddle = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && flags & mask

mask & options ^ FLAGS

TRUE ^ flag && TRUE

2 * flag || started

rate - finished && error

remember would refer back not seen

  trousers =     ____    __    __

  saddle =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

string = 5;
spoon = 6;
fork = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == flag & TRUE

flag || n < field

done || flag && finished

finished || flag + offset

TRUE || 2 * count

remember would refer back not seen

  string =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

stream = 5;
hair = 8;
river = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

VAL < finished & mask

flag & 0xff | finished

done | started == val

offset - resource < count

done ^ TRUE | bits

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  hair =     ____    __    __

plumber = 8;
pencil = 5;
painter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & TRUE && error

TRUE & offset * count

done & num + length

options & resource < 2

flag & mask << rate

remember would refer back not seen

  painter =     ____    __    __

  pencil =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

hot = 8;
saw = 5;
screwdriver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & started == resource

0xff & options ^ finished

count - offset * length

OPTIONS & bits | finished

2 - offset + num

remember would refer back not seen

  hot =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

blue = 8;
occult = 4;
green = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & bits || done

LENGTH - rate < temp

RATE / COUNT & flag

OFFSET - bits << flag

rate - num == N

remember would refer back not seen

  blue =     ____    __    __

  occult =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

table = 4;
sofa = 8;
chair = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - length ^ done

rate - done | flag

val < offset + length

2 - TRUE || started

field < num << state

remember would refer back not seen

  propeller =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  sofa =     ____    __    __

germany = 5;
france = 9;
hair = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff << started & flags

offset < rate == val

started << 2 && error

val < n ^ state

length < offset | TRUE

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

  hair =     ____    __    __

venus = 5;
mars = 6;
saddle = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < rate || finished

n == flag & FLAGS

STARTED && flag & flags

finished ^ options << length

resource == error && done

remember would refer back not seen

  saddle =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

pig = 6;
sheep = 5;
cow = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && count * 2

bits ^ FIELD == field

N == num * length

finished && RATE + count

started ^ done | mask

remember would refer back not seen

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  plastic =     ____    __    __

wasp = 4;
chapter = 6;
fly = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TEMP == field + offset

TRUE && FINISHED < 2

bits ^ flag || STARTED

flag && done << state

TRUE | mask & options

remember would refer back not seen

  chapter =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

robin = 5;
sparrow = 6;
blackbird = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && val == field

finished | TRUE && flag

finished && done ^ finished

0xff | count * offset

done && finished | options

remember would refer back not seen

  robin =     ____    __    __

  exterior =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

atom = 5;
banana = 6;
pear = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || flags ^ finished

TRUE | finished + offset

DONE && TRUE || done

error || done | mask

state | 0xff < offset

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  atom =     ____    __    __

  apple =     ____    __    __

engine = 8;
hour = 4;
minute = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask | error << TRUE

length % started && finished

offset % rate + offset

offset * 2 < field

offset % num << error

remember would refer back not seen

  engine =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

elm = 5;
oak = 6;
grass = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * field == TEMP

offset * flags ^ mask

2 * count | started

bits << length * count

count * done || started

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  grass =     ____    __    __

october = 8;
january = 5;
wood = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff << NUM + num

2 - length & mask

FINISHED << temp < length

OFFSET - rate && done

state << count == field

remember would refer back not seen

  wood =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

liver = 4;
string = 9;
lung = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset << state ^ ERROR

offset << num | done

done << 0xff || flag

val == temp < 7

resource < val & mask

remember would refer back not seen

  liver =     ____    __    __

  string =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

scrabble = 6;
solitaire = 5;
poker = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == error << MASK

val < NUM && flag

temp == flags ^ FLAGS

NUM < 2 * count

resource == error | FLAG

remember would refer back not seen

  poker =     ____    __    __

  solitaire =     ____    __    __

  lizard =     ____    __    __

  scrabble =     ____    __    __

dutch = 9;
wax = 4;
mandarin = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == TRUE || finished

flag ^ ERROR & flag

flags ^ finished && TRUE

options | started == field

done ^ 2 * length

remember would refer back not seen

  wax =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

noun = 8;
verb = 9;
adjective = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | STATE ^ started

TRUE ^ done + length

options | flag || error

done ^ FLAGS < resource

flag || bits & state

remember would refer back not seen

  noun =     ____    __    __

  tangent =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

trousers = 5;
wheel = 8;
dress = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || flag && STARTED

TRUE || started * length

flag || finished + 2

FINISHED || error < 2

TRUE || length << TRUE

remember would refer back not seen

  trousers =     ____    __    __

  wheel =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

knife = 9;
fork = 4;
spoon = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & started && error

done & started / offset

TRUE & count + 2

error & DONE < val

options & TRUE << error

remember would refer back not seen

  comb =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

kettle = 5;
canal = 8;
river = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & flags == val

started & TRUE ^ mask

rate - 2 * num

state & done | state

count - offset + length

remember would refer back not seen

  river =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

  kettle =     ____    __    __

pencil = 6;
painter = 9;
builder = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & FINISHED || error

length - count < COUNT

length * TRUE & started

rate - length << state

rate - length == n

remember would refer back not seen

  pencil =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

hot = 8;
saw = 4;
hammer = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - finished ^ options

rate - offset | TRUE

offset < 7 + rate

num - error || TRUE

N < temp << length

remember would refer back not seen

  screwdriver =     ____    __    __

  hot =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

atom = 4;
green = 9;
red = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * num + rate

done ^ state << num

TRUE | started && error

error ^ mask | options

started | TRUE || flag

remember would refer back not seen

  green =     ____    __    __

  red =     ____    __    __

  atom =     ____    __    __

  blue =     ____    __    __

table = 9;
chair = 5;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 != num + offset

resource < offset << count

error ^ flags / count

options & flag % RATE

TRUE | options % LENGTH

remember would refer back not seen

  sofa =     ____    __    __

  chair =     ____    __    __

  kettle =     ____    __    __

  table =     ____    __    __

room = 4;
sweden = 6;
france = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 - num || TRUE

2 - count * offset

error | flags + num

length - 2 + rate

val != 7 < count

remember would refer back not seen

  room =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

venus = 4;
jupiter = 9;
snake = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 << TRUE ^ bits

rate * mask & finished

0xff ^ 7 == resource

flag && 2 < num

count - STARTED ^ mask

remember would refer back not seen

  mars =     ____    __    __

  snake =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

sheep = 6;
pig = 8;
hair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != resource % 2

2 < done && started

0xff | VAL == temp

error || flag * 2

TRUE && ERROR % 2

remember would refer back not seen

  sheep =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

  hair =     ____    __    __

wheel = 5;
bee = 4;
fly = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * OFFSET < RATE

error && flag & state

n != resource << length

options | 0xff ^ finished

error || rate + RATE

remember would refer back not seen

  wheel =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

robin = 8;
engine = 9;
blackbird = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error << rate % count

state & error | TRUE

n != field ^ 0xff

temp < started & state

done ^ started + 2

remember would refer back not seen

  robin =     ____    __    __

  blackbird =     ____    __    __

  engine =     ____    __    __

  sparrow =     ____    __    __

pear = 9;
apple = 5;
chapter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ TRUE || error

flag && mask << done

2 - TRUE && done

flags << started | done

val != TRUE & FLAGS

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

  chapter =     ____    __    __

second = 6;
minute = 9;
comb = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & NUM + RATE

2 - NUM << error

mask ^ error && finished

error && finished || done

flag && FINISHED + count

remember would refer back not seen

  minute =     ____    __    __

  comb =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

chestnut = 8;
report = 9;
elm = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || done ^ TRUE

finished | count < rate

finished & error && ERROR

n < length * 2

done || error | done

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  report =     ____    __    __

june = 8;
january = 6;
october = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * 2 ^ options

error || TRUE && error

state & options ^ DONE

done << error && flag

length - rate | TRUE

remember would refer back not seen

  fence =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

liver = 4;
heart = 8;
exterior = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && flag ^ mask

flags << started & bits

count - length == val

DONE || TRUE & bits

flag & N < offset

remember would refer back not seen

  heart =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  exterior =     ____    __    __

scrabble = 6;
poker = 5;
solitaire = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num << state < count

7 < finished | flags

resource < num ^ TRUE

OFFSET - offset < OFFSET

flag << BITS || error

remember would refer back not seen

  scrabble =     ____    __    __

  grass =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

propeller = 5;
english = 6;
dutch = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & finished == temp

7 != VAL || TRUE

done || finished == FIELD

offset % count << error

flag || val < field

remember would refer back not seen

  dutch =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  propeller =     ____    __    __

verb = 8;
noun = 5;
pencil = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | finished << state

resource != 7 | state

mask << bits == val

TRUE && RESOURCE == TEMP

FLAG || bits << length

remember would refer back not seen

  verb =     ____    __    __

  pencil =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

trousers = 5;
saddle = 8;
shirt = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG & flag || TRUE

mask ^ 0xff < OFFSET

done && ERROR | done

done | error & 0xff

count - length & flag

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  dress =     ____    __    __

  saddle =     ____    __    __

fork = 5;
lizard = 9;
spoon = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & started << count

temp < 7 == resource

length << mask + 2

LENGTH / length == resource

7 != flag && started

remember would refer back not seen

  fork =     ____    __    __

  spoon =     ____    __    __

  lizard =     ____    __    __

  knife =     ____    __    __

pencil = 8;
canal = 4;
stream = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * started || error

resource != 7 == val

2 * finished && flag

length * count | started

offset < error || done

remember would refer back not seen

  pencil =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

painter = 4;
hair = 5;
plumber = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != finished || done

flag && done & flags

TRUE && flag / offset

finished && started + count

TRUE && offset < RESOURCE

remember would refer back not seen

  builder =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

  hair =     ____    __    __

saw = 5;
pencil = 9;
screwdriver = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && num << started

error && field == temp

2 * offset && started

finished && done ^ bits

offset * num + offset

remember would refer back not seen

  hammer =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

  pencil =     ____    __    __

red = 8;
blue = 9;
green = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && finished | flags

num * COUNT < n

TRUE && done || flag

RATE * options << LENGTH

2 % resource == n

remember would refer back not seen

  red =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  tail =     ____    __    __

table = 5;
chair = 9;
sofa = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * 2 ^ 0xff

2 * offset | mask

flags << length % rate

length * TRUE || started

DONE << 0xff + length

remember would refer back not seen

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  snake =     ____    __    __

germany = 4;
sweden = 9;
wax = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count - num & options

FINISHED << length < n

rate - done && TRUE

bits << OPTIONS == temp

flags << options ^ TRUE

remember would refer back not seen

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

  wax =     ____    __    __

jupiter = 5;
venus = 9;
mars = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

BITS << TRUE | started

offset << flags || error

val != temp & flags

options ^ resource < val

length < 7 & flags

remember would refer back not seen

  venus =     ____    __    __

  report =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

cow = 6;
pencil = 4;
sheep = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != started && finished

flags ^ finished << options

rate < finished && flag

n != length * offset

flags ^ n == temp

remember would refer back not seen

  pig =     ____    __    __

  sheep =     ____    __    __

  pencil =     ____    __    __

  cow =     ____    __    __

wasp = 6;
fly = 8;
hot = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < num / length

val != length + 2

0xff ^ MASK | TRUE

resource != offset < RESOURCE

flag ^ 0xff || finished

remember would refer back not seen

  hot =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

sparrow = 4;
blackbird = 8;
room = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != 7 << offset

done | finished & mask

n != val == n

MASK | state && finished

temp != val ^ TRUE

remember would refer back not seen

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  room =     ____    __    __

banana = 9;
pear = 5;
apple = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || TRUE == 7

done | started * length

resource != flags | TRUE

error || 0xff ^ mask

flag | length + RATE

remember would refer back not seen

  lizard =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

minute = 8;
comb = 6;
second = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || ERROR | flag

done | 7 < resource

flags & flag && error

bits & started / offset

state & rate + COUNT

remember would refer back not seen

  second =     ____    __    __

  comb =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

elm = 5;
chestnut = 4;
oak = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & mask < field

bits & flags << state

done & state == val

options & error ^ TRUE

offset - count * num

remember would refer back not seen

  oak =     ____    __    __

  petrol =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

june = 9;
january = 4;
wood = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & error | MASK

2 - rate + length

TRUE & done || ERROR

2 - resource < val

2 * options & 0xff

remember would refer back not seen

  october =     ____    __    __

  wood =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

lung = 4;
plastic = 8;
heart = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - options << finished

rate - temp == resource

count - offset ^ flags

length - rate | error

field < n + rate

remember would refer back not seen

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

  plastic =     ____    __    __

grass = 5;
solitaire = 6;
scrabble = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - flag || TRUE

7 < num << finished

done << options & bits

rate < field == resource

2 << flag && finished

remember would refer back not seen

  scrabble =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

  grass =     ____    __    __

dutch = 5;
english = 9;
propeller = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < offset ^ bits

field < error | started

field < TRUE || flag

TRUE ^ error & flags

mask | started << finished

remember would refer back not seen

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  propeller =     ____    __    __

verb = 4;
plastic = 9;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ options && started

FLAG | flag == field

mask ^ offset * 2

state | 0xff ^ FINISHED

0xff ^ STATE + rate

remember would refer back not seen

  plastic =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

shirt = 8;
tangent = 9;
dress = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff | OPTIONS || TRUE

flag || TRUE & flags

flag || TRUE && error

started || num * rate

started || error + offset

remember would refer back not seen

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

  tangent =     ____    __    __

knife = 6;
occult = 8;
fork = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource != started || TRUE

finished && error & mask

done && 2 / rate

ERROR && TRUE + length

TRUE && started < 7

remember would refer back not seen

  knife =     ____    __    __

  spoon =     ____    __    __

  occult =     ____    __    __

  fork =     ____    __    __

river = 6;
stream = 9;
canal = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && flag << mask

started && TRUE == resource

num * finished && TRUE

finished && done ^ TRUE

2 * count + 2

remember would refer back not seen

  atom =     ____    __    __

  canal =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

painter = 9;
plumber = 5;
builder = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR && started | flags

num * count < length

TRUE && flag || started

num * started << TRUE

rate % 2 == temp

remember would refer back not seen

  hair =     ____    __    __

  builder =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

pencil = 9;
saw = 8;
hammer = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * offset ^ TRUE

length * 0xff | started

finished << length * num

rate * 2 || flag

error << count + 2

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  pencil =     ____    __    __

  saw =     ____    __    __

blue = 9;
red = 5;
green = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != n && started

finished ^ started + rate

length < resource == field

started || count << mask

resource < rate + offset

remember would refer back not seen

  fence =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

comb = 8;
chair = 6;
sofa = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags | rate * offset

2 < offset << flag

FLAGS | done && TRUE

started && flag | error

7 != field * length

remember would refer back not seen

  table =     ____    __    __

  sofa =     ____    __    __

  comb =     ____    __    __

  chair =     ____    __    __

germany = 8;
sweden = 5;
membrane = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FINISHED ^ error && done

offset - rate + offset

flag && length + 2

error | n == 7

flag && n == field

remember would refer back not seen

  sweden =     ____    __    __

  membrane =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

propeller = 9;
mars = 4;
venus = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * options ^ bits

val != done ^ state

7 != finished & flag

count - rate & state

error && TRUE / count

remember would refer back not seen

  mars =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

  propeller =     ____    __    __

report = 5;
sheep = 9;
cow = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 < rate * count

flags ^ TRUE | error

started || VAL == n

done && flag << bits

bits ^ temp == val

remember would refer back not seen

  sheep =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

  report =     ____    __    __

wasp = 4;
wax = 6;
bee = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & RESOURCE == temp

bits & rate + num

offset - TEMP == n

field != temp == N

finished || 2 % offset

remember would refer back not seen

  wax =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

blackbird = 8;
sparrow = 5;
snake = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || length + num

rate * count << error

error << 0xff < n

TRUE ^ error || flag

started || TRUE < resource

remember would refer back not seen

  robin =     ____    __    __

  sparrow =     ____    __    __

  snake =     ____    __    __

  blackbird =     ____    __    __

pear = 5;
plastic = 4;
apple = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & flags | flag

offset - 0XFF << count

bits ^ 0XFF & 0xff

2 * length + offset

finished && done & started

remember would refer back not seen

  pear =     ____    __    __

  apple =     ____    __    __

  plastic =     ____    __    __

  banana =     ____    __    __

second = 8;
minute = 9;
hour = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask ^ error < 2

finished || ERROR & flags

TRUE || done && flag

count - started | ERROR

val != finished || done

remember would refer back not seen

  hour =     ____    __    __

  second =     ____    __    __

  minute =     ____    __    __

  petrol =     ____    __    __

occult = 4;
elm = 8;
chestnut = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options | flags & flag

mask & num % offset

count < resource ^ options

state | n < val

mask << flags | 0xff

remember would refer back not seen

  chestnut =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

  occult =     ____    __    __

october = 4;
january = 8;
atom = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < finished | error

FLAGS << temp == field

options << length * offset

0xff & flags ^ state

2 - rate || FLAG

remember would refer back not seen

  june =     ____    __    __

  january =     ____    __    __

  october =     ____    __    __

  atom =     ____    __    __

liver = 4;
heart = 8;
wood = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started ^ 2 * offset

count < finished & flag

count << done || finished

FLAG | state || started

FIELD != field + count

remember would refer back not seen

  heart =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  wood =     ____    __    __

solitaire = 6;
poker = 9;
hot = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * done | 0xff

finished & flag && started

temp != TRUE | started

count * offset < count

finished << flag + count

remember would refer back not seen

  poker =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  hot =     ____    __    __

dutch = 4;
english = 8;
mandarin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && error || done

rate - length < offset

done && error ^ flags

2 << flags & mask

rate - offset * 2

remember would refer back not seen

  pencil =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

verb = 9;
hair = 5;
noun = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * state & OPTIONS

bits << TRUE && started

count / num == resource

7 != field < 7

mask | bits << rate

remember would refer back not seen

  hair =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

dress = 5;
tangent = 9;
shirt = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != val << flag

STARTED || ERROR | OPTIONS

state ^ flag << rate

length * done && TRUE

offset % finished || error

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  tangent =     ____    __    __

  trousers =     ____    __    __

fork = 4;
spoon = 9;
plastic = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count - FLAGS ^ flag

TRUE | bits ^ flag

options & resource < 7

offset < error && flag

started || finished ^ MASK

remember would refer back not seen

  knife =     ____    __    __

  plastic =     ____    __    __

  spoon =     ____    __    __

  fork =     ____    __    __

stream = 6;
river = 5;
canal = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < num || TRUE

finished && n < num

count << done ^ mask

OFFSET - finished && done

started & bits || finished

remember would refer back not seen

  grass =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

builder = 5;
saddle = 6;
plumber = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != error || DONE

done && finished & bits

DONE && done * length

TRUE && offset + OFFSET

TRUE && resource < field

remember would refer back not seen

  plumber =     ____    __    __

  painter =     ____    __    __

  saddle =     ____    __    __

  builder =     ____    __    __

saw = 6;
hammer = 9;
screwdriver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && started << done

ERROR && n == RESOURCE

count * TRUE && flag

TRUE && STARTED ^ flag

rate * 2 + rate

remember would refer back not seen

  report =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

red = 5;
green = 9;
blue = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR && started | finished

num % length < rate

flag && done || error

OFFSET / rate << 2

num % offset == val

remember would refer back not seen

  comb =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

sofa = 8;
chair = 6;
table = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * flags ^ error

offset % flags | started

mask << num * RATE

LENGTH * finished || started

count << num + count

remember would refer back not seen

  table =     ____    __    __

  pencil =     ____    __    __

  sofa =     ____    __    __

  chair =     ____    __    __

france = 9;
germany = 6;
sweden = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

COUNT - count & 0xff

rate << MASK < offset

COUNT - offset && finished

LENGTH << field == RESOURCE

flags << bits ^ flag

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  grass =     ____    __    __

  germany =     ____    __    __

wax = 4;
mars = 9;
jupiter = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error << count | error

0xff << started || finished

val != done & flag

flags ^ RESOURCE < num

n < 2 & FINISHED

remember would refer back not seen

  wax =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

cow = 5;
occult = 4;
sheep = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RESOURCE != TRUE && flag

OPTIONS ^ started << offset

resource < val && flag

7 != 2 * count

error ^ STATE == resource

remember would refer back not seen

  pig =     ____    __    __

  occult =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

wasp = 8;
tangent = 9;
bee = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < length * offset

temp != num + NUM

flags ^ state | FLAG

RESOURCE != resource < offset

done ^ flag || TRUE

remember would refer back not seen

  wasp =     ____    __    __

  tangent =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

plastic = 5;
robin = 4;
sparrow = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp != val << error

0xff | bits & finished

field != n == VAL

flags | error && started

7 != TRUE ^ started

remember would refer back not seen

  robin =     ____    __    __

  sparrow =     ____    __    __

  plastic =     ____    __    __

  blackbird =     ____    __    __

pear = 8;
apple = 9;
banana = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || resource == temp

started | length * count

val != n | options

error || options ^ done

flag | RATE + offset

remember would refer back not seen

  occult =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

hour = 5;
minute = 4;
exterior = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || TRUE | mask

OPTIONS | val < field

BITS & flag && started

done & num * 2

TRUE & options + rate

remember would refer back not seen

  minute =     ____    __    __

  second =     ____    __    __

  exterior =     ____    __    __

  hour =     ____    __    __

elm = 4;
oak = 9;
plastic = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & length < temp

state & TRUE << bits

options & field == FIELD

flags & done ^ error

2 - num % 2

remember would refer back not seen

  oak =     ____    __    __

  plastic =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

october = 6;
january = 4;
june = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & OPTIONS | mask

rate - offset + num

flags & flag || done

2 - rate < val

rate * finished & options

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

  atom =     ____    __    __

heart = 6;
liver = 4;
lung = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM - done << flag

offset - rate == field

num - options ^ 0xff

length - finished | options

2 < rate + num

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  chapter =     ____    __    __

  lung =     ____    __    __

solitaire = 4;
string = 8;
poker = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - finished || error

7 < STATE << 0xff

started << state & finished

2 < resource == n

FINISHED << finished && TRUE

remember would refer back not seen

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  string =     ____    __    __

room = 5;
dutch = 9;
english = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < TRUE ^ state

count < field | 0xff

offset < TRUE || flag

options ^ flags & mask

state | TRUE << bits

remember would refer back not seen

  dutch =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

  room =     ____    __    __

verb = 6;
adjective = 4;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ started && finished

state | flags == n

flags ^ 2 * length

TRUE | flag ^ bits

finished ^ options + num

remember would refer back not seen

  adjective =     ____    __    __

  verb =     ____    __    __

  wheel =     ____    __    __

  noun =     ____    __    __

shirt = 4;
pencil = 9;
dress = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | FINISHED || flag

finished || error & flag

TRUE || flag && done

done || error * offset

flag || error + count

remember would refer back not seen

  pencil =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

spoon = 6;
engine = 5;
fork = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

VAL != field || finished

error && started & state

finished && offset * length

error && COUNT + 2

started && 7 < length

remember would refer back not seen

  fork =     ____    __    __

  engine =     ____    __    __

  spoon =     ____    __    __

  knife =     ____    __    __

canal = 8;
river = 5;
hot = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && state << rate

FINISHED && flag == 7

length * error && finished

FINISHED && flags ^ bits

length * 2 + num

remember would refer back not seen

  stream =     ____    __    __

  canal =     ____    __    __

  river =     ____    __    __

  hot =     ____    __    __

saddle = 4;
plumber = 6;
builder = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && mask | state

rate % 2 < val

finished && done || ERROR

count / started << TRUE

2 * resource == 7

remember would refer back not seen

  painter =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

  saddle =     ____    __    __

hammer = 9;
saw = 4;
report = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * num ^ flag

2 * offset | state

FLAGS << 0XFF * offset

length * count || started

mask << 2 + num

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  report =     ____    __    __

  saw =     ____    __    __

kettle = 5;
green = 4;
blue = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == rate < resource

finished || done ^ finished

count + VAL == temp

flag && TRUE || finished

done && TRUE << num

remember would refer back not seen

  kettle =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

engine = 9;
table = 8;
sofa = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state | error << 0xff

started ^ 0xff && flag

options & n < length

error ^ finished < 7

started | done == resource

remember would refer back not seen

  chair =     ____    __    __

  engine =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

sweden = 4;
france = 8;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAGS ^ error / OFFSET

TRUE << flag | TRUE

0xff ^ started || flag

flag && finished & mask

offset % error || flag

remember would refer back not seen

  germany =     ____    __    __

  france =     ____    __    __

  occult =     ____    __    __

  sweden =     ____    __    __

wheel = 5;
venus = 8;
jupiter = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || TRUE && error

done || val < 2

offset + rate * offset

done & TRUE == field

length * started ^ TRUE

remember would refer back not seen

  wheel =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

sheep = 5;
cow = 9;
grass = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ rate + num

count << num < 2

2 * flag << finished

FIELD < 2 || DONE

done | error + count

remember would refer back not seen

  pig =     ____    __    __

  sheep =     ____    __    __

  grass =     ____    __    __

  cow =     ____    __    __

petrol = 4;
wasp = 6;
bee = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length % 2 + num

finished | TRUE ^ done

val == 2 + rate

flag & TRUE | 0xff

resource == val * offset

remember would refer back not seen

  fly =     ____    __    __

  petrol =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

room = 6;
sparrow = 9;
blackbird = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished << rate && TRUE

started << finished + 2

finished | state & done

TRUE || length + count

COUNT < length | bits

remember would refer back not seen

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

  room =     ____    __    __

apple = 8;
snake = 5;
banana = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == flags & done

length + started & error

temp < rate << done

bits ^ finished << flag

7 == finished && error

remember would refer back not seen

  snake =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

pencil = 9;
hour = 8;
second = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & flag << TRUE

num < flags ^ error

error || done & finished

flag | length < offset

rate < length % 2

remember would refer back not seen

  minute =     ____    __    __

  pencil =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

elm = 8;
oak = 6;
wax = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished << FLAGS || done

0xff & state ^ done

state ^ field == 7

offset << count == temp

FIELD == resource | state

remember would refer back not seen

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

  wax =     ____    __    __

comb = 8;
june = 9;
january = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == TRUE || error

flag ^ FINISHED | finished

TRUE && flag | bits

FIELD < field == n

val < field && flag

remember would refer back not seen

  october =     ____    __    __

  comb =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

atom = 9;
liver = 8;
heart = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + length << mask

offset * count && finished

flags | ERROR || FLAG

TRUE || done << TRUE

TRUE || started | state

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  heart =     ____    __    __

  atom =     ____    __    __

poker = 9;
scrabble = 8;
saddle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ options & finished

length << state ^ MASK

resource < num + count

TRUE || error == n

started || 2 * offset

remember would refer back not seen

  saddle =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

tangent = 5;
dutch = 9;
english = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * length < count

offset + length < NUM

rate << 2 & TRUE

count < options & done

NUM + flag | TRUE

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

  tangent =     ____    __    __

plastic = 8;
adjective = 9;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | 0XFF * offset

count << rate / count

OFFSET + rate || DONE

state & started || error

0xff & length + rate

remember would refer back not seen

  verb =     ____    __    __

  plastic =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

plastic = 6;
trousers = 4;
shirt = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * error | done

DONE && done == n

finished & error && done

field == temp << num

started && length + offset

remember would refer back not seen

  trousers =     ____    __    __

  shirt =     ____    __    __

  plastic =     ____    __    __

  dress =     ____    __    __

fence = 5;
fork = 9;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff | MASK && started

length + finished && DONE

RATE * count & TRUE

length + 0xff ^ flag

temp == N ^ BITS

remember would refer back not seen

  spoon =     ____    __    __

  knife =     ____    __    __

  fence =     ____    __    __

  fork =     ____    __    __

canal = 6;
river = 8;
hair = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR && num * offset

finished && temp < 2

offset * 7 == resource

bits & num * length

TRUE && mask ^ started

remember would refer back not seen

  river =     ____    __    __

  stream =     ____    __    __

  hair =     ____    __    __

  canal =     ____    __    __

painter = 4;
builder = 5;
plumber = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & ERROR && TRUE

TRUE & FLAG * rate

error & flag + length

BITS & 0xff < RESOURCE

error & num << state

remember would refer back not seen

  painter =     ____    __    __

  plumber =     ____    __    __

  snake =     ____    __    __

  builder =     ____    __    __

saw = 6;
petrol = 5;
hammer = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAGS & TRUE == field

0xff & finished ^ done

2 + num * rate

started & TRUE | flag

length + field < count

remember would refer back not seen

  petrol =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

hot = 8;
blue = 4;
red = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & done || flag

OFFSET + offset << started

2 / offset & 0xff

num + length == resource

offset + bits ^ FLAG

remember would refer back not seen

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  hot =     ____    __    __

table = 8;
sofa = 9;
chair = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + TRUE | error

count + offset || started

COUNT < TEMP << length

done << flags & state

temp < count == 7

remember would refer back not seen

  chair =     ____    __    __

  propeller =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

germany = 8;
sweden = 4;
france = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff << num && done

length < started ^ 0xff

mask << error * offset

7 < rate | TRUE

temp < n || flag

remember would refer back not seen

  germany =     ____    __    __

  saddle =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

jupiter = 6;
pencil = 8;
venus = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == field & mask

n == resource && error

ERROR && started & mask

flag ^ DONE == field

n == rate * num

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  pencil =     ____    __    __

cow = 9;
engine = 6;
sheep = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && started * num

TRUE ^ BITS | finished

val == rate + length

error && num + OFFSET

MASK ^ flags || FLAG

remember would refer back not seen

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  engine =     ____    __    __

fly = 6;
bee = 9;
grass = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == 7 < count

error && done < field

finished | done & OPTIONS

error && rate << count

started | done && error

remember would refer back not seen

  grass =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

robin = 6;
sparrow = 5;
blackbird = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && val == TEMP

0XFF | options * offset

error && flag ^ TRUE

mask | flag + length

error && done | TRUE

remember would refer back not seen

  robin =     ____    __    __

  blackbird =     ____    __    __

  string =     ____    __    __

  sparrow =     ____    __    __

pear = 4;
plastic = 5;
apple = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || finished | TRUE

flag | error < VAL

flag && started || flag

TRUE | started << flags

finished | 0xff == resource

remember would refer back not seen

  banana =     ____    __    __

  apple =     ____    __    __

  plastic =     ____    __    __

  pear =     ____    __    __

second = 9;
wood = 4;
minute = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * TRUE && flag

count * length + count

count * 7 < offset

rate * LENGTH << bits

length % rate == field

remember would refer back not seen

  hour =     ____    __    __

  second =     ____    __    __

  wood =     ____    __    __

  minute =     ____    __    __

elm = 5;
oak = 6;
chestnut = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count * num ^ state

count % offset | started

0xff << offset + count

NUM * count || error

finished << n < RATE

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  lizard =     ____    __    __

october = 4;
january = 5;
kettle = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + rate & done

mask << val == n

length + FINISHED && finished

state << bits ^ 0xff

options << offset | ERROR

remember would refer back not seen

  kettle =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

occult = 9;
lung = 6;
liver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag << 0xff || TRUE

val < 0xff & mask

7 == VAL << TRUE

n < error && started

TEMP == field ^ error

remember would refer back not seen

  lung =     ____    __    __

  occult =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

poker = 6;
solitaire = 4;
plastic = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < rate * COUNT

n == field | options

temp < offset + count

temp == val || flag

finished ^ options & finished

remember would refer back not seen

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  plastic =     ____    __    __

english = 4;
room = 9;
mandarin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ flags && done

0xff ^ flag * rate

flag | done ^ 0xff

0xff ^ num + count

0xff | done || started

remember would refer back not seen

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

  room =     ____    __    __

chapter = 9;
verb = 6;
noun = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ length < offset

done || error & bits

started ^ state << mask

STARTED || done && error

error || started * length

remember would refer back not seen

  verb =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

  chapter =     ____    __    __

pencil = 9;
shirt = 5;
dress = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || count + 2

flag || length < rate

finished || MASK << flags

error || field == resource

TRUE || STARTED ^ OPTIONS

remember would refer back not seen

  pencil =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

knife = 6;
exterior = 8;
spoon = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & TRUE && error

flags & rate * length

ERROR & 0xff + 2

0xff & bits < resource

flags & done << length

remember would refer back not seen

  exterior =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

river = 8;
tail = 6;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & field == val

flags & TRUE ^ flag

count + rate * 2

FLAG & options | flag

offset + count < length

remember would refer back not seen

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

  tail =     ____    __    __

painter = 4;
plumber = 8;
snake = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & error || done

count + length << 2

COUNT * done & options

length + 2 == resource

2 + rate ^ STATE

remember would refer back not seen

  builder =     ____    __    __

  painter =     ____    __    __

  plumber =     ____    __    __

  snake =     ____    __    __

screwdriver = 5;
saw = 4;
hammer = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + done | OPTIONS

offset + TRUE || done

7 < 0XFF << rate

bits << mask & flag

7 < n == temp

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  petrol =     ____    __    __

  hammer =     ____    __    __

blue = 4;
green = 5;
tangent = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val < TRUE & error

TRUE << TEMP == resource

error && FINISHED + offset

done && finished || DONE

rate % count ^ FLAG

remember would refer back not seen

  blue =     ____    __    __

  red =     ____    __    __

  tangent =     ____    __    __

  green =     ____    __    __

chapter = 4;
sofa = 5;
table = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * OFFSET << done

STARTED | OPTIONS & finished

rate - state & bits

num < 7 || flag

finished && val == n

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  chapter =     ____    __    __

lizard = 5;
france = 4;
sweden = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state << length % rate

bits | error == val

2 * offset & flags

finished | done + length

rate << started && finished

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

  lizard =     ____    __    __

venus = 5;
report = 8;
jupiter = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & started == temp

rate - offset && DONE

count * 2 + offset

flags << OPTIONS | bits

mask ^ finished && done

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  report =     ____    __    __

string = 5;
sheep = 4;
cow = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & flags | error

done || offset << finished

finished || STARTED & TRUE

resource == count + rate

RATE << 0xff & DONE

remember would refer back not seen

  cow =     ____    __    __

  sheep =     ____    __    __

  pig =     ____    __    __

  string =     ____    __    __

wasp = 5;
fly = 9;
bee = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - 2 * count

TRUE ^ offset * count

2 - started || TRUE

done && finished < val

num - flag ^ finished

remember would refer back not seen

  hot =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

hair = 5;
robin = 9;
sparrow = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ offset << options

mask | FLAGS ^ 0xff

count * num < resource

flag & rate < 7

error && done << flags

remember would refer back not seen

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  robin =     ____    __    __

  hair =     ____    __    __

banana = 8;
pear = 5;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp < 7 && flag

error || val == N

started && error | mask

offset < 7 == TEMP

rate < num * count

remember would refer back not seen

  occult =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

  pear =     ____    __    __

hour = 8;
second = 6;
minute = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options ^ 0xff | error

error | options || started

error || started ^ mask

2 - offset + count

STATE ^ field < n

remember would refer back not seen

  petrol =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

elm = 9;
occult = 8;
oak = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & started || FLAG

rate - num << done

flag ^ TRUE || started

ERROR & flags * rate

finished || flag | flags

remember would refer back not seen

  oak =     ____    __    __

  chestnut =     ____    __    __

  occult =     ____    __    __

  elm =     ____    __    __

june = 8;
tail = 6;
january = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && 0xff & finished

length << 7 < rate

0xff | flags < length

bits | state * num

val == resource | bits

remember would refer back not seen

  october =     ____    __    __

  tail =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

lung = 5;
liver = 9;
wood = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options << 2 + offset

BITS ^ 0xff & flag

error ^ finished == n

MASK | done && TRUE

temp == val << bits

remember would refer back not seen

  heart =     ____    __    __

  liver =     ____    __    __

  wood =     ____    __    __

  lung =     ____    __    __

fence = 6;
solitaire = 4;
poker = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length - num < NUM

N == rate < resource

done || 2 % rate

finished << length || started

offset << state ^ flag

remember would refer back not seen

  fence =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

english = 9;
atom = 5;
mandarin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == field && done

val == n ^ TRUE

finished && num % offset

RATE * num || TRUE

val == temp || TRUE

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

  atom =     ____    __    __

adjective = 6;
noun = 4;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < val ^ flags

7 == flag & started

TRUE || error && TRUE

flag || started < 7

2 * num == val

remember would refer back not seen

  noun =     ____    __    __

  propeller =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

shirt = 5;
dress = 9;
trousers = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == n * num

mask | options << TRUE

resource < length << 0xff

done && error ^ ERROR

count * state | TRUE

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  comb =     ____    __    __

  trousers =     ____    __    __

fork = 4;
spoon = 6;
knife = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * flag && error

started || 2 + length

started & done << TRUE

finished ^ count + 2

offset - N == 7

remember would refer back not seen

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

  snake =     ____    __    __

canal = 6;
river = 4;
stream = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & TRUE && finished

started & count + rate

0xff & flag ^ options

count - 2 | options

resource < rate + 2

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  wax =     ____    __    __

plastic = 9;
painter = 6;
plumber = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & done && finished

finished & num / count

bits & DONE + count

0xff & started < 2

0XFF & flags << FLAG

remember would refer back not seen

  plumber =     ____    __    __

  painter =     ____    __    __

  plastic =     ____    __    __

  builder =     ____    __    __

hammer = 9;
screwdriver = 8;
petrol = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & 7 == field

finished & 0xff ^ started

rate - length * LENGTH

mask & finished | bits

offset - count + rate

remember would refer back not seen

  screwdriver =     ____    __    __

  petrol =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

grass = 9;
green = 6;
blue = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & done || flag

num - field < num

rate / 2 & FLAGS

2 - state << ERROR

num - val == field

remember would refer back not seen

  blue =     ____    __    __

  grass =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

chair = 5;
sofa = 6;
tail = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - length ^ options

rate - error | bits

num < length + rate

rate - count || error

FIELD < FINISHED << 2

remember would refer back not seen

  table =     ____    __    __

  chair =     ____    __    __

  tail =     ____    __    __

  sofa =     ____    __    __

france = 6;
string = 8;
sweden = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state << TRUE & flag

N < field == n

MASK << error && done

2 < num ^ flags

n < TRUE | flags

remember would refer back not seen

  france =     ____    __    __

  germany =     ____    __    __

  string =     ____    __    __

  sweden =     ____    __    __

mars = 4;
occult = 5;
venus = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < offset || started

val == options & finished

finished && bits & started

flag ^ error << 2

7 == finished && started

remember would refer back not seen

  mars =     ____    __    __

  jupiter =     ____    __    __

  occult =     ____    __    __

  venus =     ____    __    __

sheep = 8;
pig = 5;
cow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && done * rate

bits ^ FLAG == resource

temp == RESOURCE * offset

TRUE && started + count

flag ^ state | flags

remember would refer back not seen

  wood =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

bee = 6;
fly = 4;
wasp = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == temp + rate

TRUE && 7 < resource

started ^ mask || finished

flag && length << OFFSET

0xff | error & started

remember would refer back not seen

  wasp =     ____    __    __

  bee =     ____    __    __

  saddle =     ____    __    __

  fly =     ____    __    __

hair = 5;
sparrow = 8;
blackbird = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && started == val

ERROR | error && done

started && done ^ finished

options | state / rate

TRUE && error | mask

remember would refer back not seen

  hair =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

banana = 6;
pear = 4;
hot = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || done ^ TRUE

TRUE | flag + length

done && TRUE || done

TRUE || FLAG | TRUE

done | val < COUNT

remember would refer back not seen

  hot =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

  apple =     ____    __    __

fence = 9;
hour = 8;
minute = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask | flag << length

offset * length && flag

2 % count + rate

num % length < rate

COUNT * mask << offset

remember would refer back not seen

  fence =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

  minute =     ____    __    __

oak = 6;
propeller = 5;
chestnut = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset % resource == n

count * COUNT ^ finished

num / finished | bits

length << num * rate

num * 2 || started

remember would refer back not seen

  chestnut =     ____    __    __

  propeller =     ____    __    __

  oak =     ____    __    __

  elm =     ____    __    __

january = 4;
june = 5;
engine = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STATE << error + rate

length - offset & STARTED

flags << 2 < offset

num - done && finished

num << VAL == n

remember would refer back not seen

  engine =     ____    __    __

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

occult = 4;
lung = 8;
heart = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started << bits ^ options

error << OPTIONS | bits

0XFF << flag || error

resource == val < count

offset < TRUE & state

remember would refer back not seen

  heart =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

  occult =     ____    __    __

solitaire = 9;
scrabble = 8;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == temp << TRUE

7 < error && flag

7 == TEMP ^ mask

field < num * rate

temp == started | options

remember would refer back not seen

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  poker =     ____    __    __

  chapter =     ____    __    __

english = 5;
kettle = 9;
mandarin = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == finished || error

mask ^ flags & mask

mask ^ TRUE && started

0xff | temp == resource

started ^ offset * count

remember would refer back not seen

  english =     ____    __    __

  mandarin =     ____    __    __

  kettle =     ____    __    __

  dutch =     ____    __    __

verb = 9;
adjective = 4;
noun = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG | flag ^ state

finished ^ bits + 2

finished | 0xff || done

mask ^ done < resource

done || error & started

remember would refer back not seen

  noun =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

  lizard =     ____    __    __

trousers = 9;
dress = 8;
shirt = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || error && flag

done || finished / offset

STARTED || 2 + length

TRUE || count < rate

flag || STARTED << num

remember would refer back not seen

  trousers =     ____    __    __

  snake =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

fork = 6;
report = 9;
spoon = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK & mask && started

finished & LENGTH * num

finished & length + offset

finished & offset < 2

options & TRUE << mask

remember would refer back not seen

  fork =     ____    __    __

  knife =     ____    __    __

  report =     ____    __    __

  spoon =     ____    __    __

stream = 4;
wax = 5;
canal = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state & n == val

FINISHED & ERROR ^ flags

2 - count * rate

options & mask | error

rate - NUM + rate

remember would refer back not seen

  wax =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

plumber = 9;
painter = 4;
builder = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & TRUE || started

offset - field < length

offset * rate & started

length - count << NUM

rate - VAL == temp

remember would refer back not seen

  painter =     ____    __    __

  builder =     ____    __    __

  plastic =     ____    __    __

  plumber =     ____    __    __

saw = 6;
screwdriver = 5;
petrol = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - error ^ finished

RATE - offset | MASK

length < resource + 2

2 - num || error

temp < started << error

remember would refer back not seen

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

  petrol =     ____    __    __

blue = 9;
red = 4;
wax = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error << length - 2

val < flag || finished

temp == MASK | bits

offset * field < resource

error << FLAG || started

remember would refer back not seen

  wax =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

sofa = 5;
table = 4;
chair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done << offset == temp

options | ERROR == val

length * offset || TRUE

num + length * rate

num << started | done

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

  plastic =     ____    __    __

sweden = 8;
wheel = 9;
france = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits ^ offset - rate

TRUE & flag ^ done

done | FLAGS && ERROR

FLAG && TRUE - num

flags ^ started * LENGTH

remember would refer back not seen

  germany =     ____    __    __

  sweden =     ____    __    __

  wheel =     ____    __    __

  france =     ____    __    __

venus = 4;
jupiter = 6;
mars = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || finished & bits

7 == length - rate

mask & started << count

state ^ error & state

length < bits << error

remember would refer back not seen

  string =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

hair = 5;
sheep = 9;
cow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * count - offset

TRUE && num / count

num + count - offset

length + temp < n

rate * 2 | flags

remember would refer back not seen

  pig =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

  hair =     ____    __    __

wasp = 5;
bee = 8;
hot = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started ^ finished && started

TRUE ^ finished || flag

flags & ERROR == field

TRUE || error == val

ERROR && state << 2

remember would refer back not seen

  hot =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

kettle = 9;
sparrow = 5;
blackbird = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | error ^ finished

error && 7 < temp

FLAG && TRUE | 0xff

FINISHED && done || finished

resource == offset % rate

remember would refer back not seen

  kettle =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

pear = 4;
apple = 8;
banana = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && temp == resource

bits | error & mask

bits | count << rate

num + RATE && STARTED

resource == 7 && error

remember would refer back not seen

  banana =     ____    __    __

  pear =     ____    __    __

  pencil =     ____    __    __

  apple =     ____    __    __

hour = 4;
report = 8;
minute = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + flag ^ TRUE

error || 0xff | started

2 < length & error

length < num | mask

rate < length - num

remember would refer back not seen

  minute =     ____    __    __

  report =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

elm = 8;
oak = 6;
room = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + val == 7

offset + started || flag

options & state | 0xff

N == field ^ state

mask | error * offset

remember would refer back not seen

  chestnut =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

  room =     ____    __    __

october = 6;
june = 8;
january = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + FINISHED << error

offset / n == resource

n == temp || done

7 == state << TRUE

mask << bits & error

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  fence =     ____    __    __

  october =     ____    __    __

tail = 4;
heart = 5;
lung = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource < length == field

started & TRUE - rate

rate < finished ^ mask

flag && finished & started

2 * rate ^ bits

remember would refer back not seen

  tail =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

solitaire = 4;
scrabble = 8;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || error * num

TRUE || finished && started

flag && state ^ error

field < RATE && flag

state & started && finished

remember would refer back not seen

  solitaire =     ____    __    __

  poker =     ____    __    __

  wood =     ____    __    __

  scrabble =     ____    __    __

snake = 5;
mandarin = 8;
dutch = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FIELD == 7 & options

length * LENGTH & state

options ^ finished < 2

done & num * rate

TRUE | offset < field

remember would refer back not seen

  mandarin =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

  snake =     ____    __    __

verb = 8;
noun = 9;
adjective = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options ^ temp == resource

state & flag < length

options << mask ^ finished

done || flag - 2

val < num * offset

remember would refer back not seen

  comb =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

shirt = 5;
trousers = 6;
dress = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags | TRUE || error

error << count % 2

2 * count && flag

COUNT << 2 < num

val == offset < n

remember would refer back not seen

  trousers =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

  plastic =     ____    __    __

spoon = 4;
knife = 6;
fork = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ 0xff | flags

0xff & error || started

num + rate | done

ERROR || finished ^ TRUE

length * STARTED << done

remember would refer back not seen

  lizard =     ____    __    __

  fork =     ____    __    __

  knife =     ____    __    __

  spoon =     ____    __    __

pencil = 4;
river = 8;
canal = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || val < n

state ^ finished << offset

ERROR | num - count

STARTED << TRUE && error

flag || FLAG << done

remember would refer back not seen

  river =     ____    __    __

  canal =     ____    __    __

  stream =     ____    __    __

  pencil =     ____    __    __

chapter = 4;
plumber = 8;
builder = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & TRUE && ERROR

mask & count * length

state & length - rate

options & 7 < resource

flag & options << mask

remember would refer back not seen

  builder =     ____    __    __

  painter =     ____    __    __

  chapter =     ____    __    __

  plumber =     ____    __    __

plastic = 6;
saw = 5;
screwdriver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG & field == val

options & started ^ flags

COUNT + num * count

done & 0XFF | TRUE

rate + offset - 2

remember would refer back not seen

  plastic =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

  screwdriver =     ____    __    __

green = 6;
red = 8;
blue = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & TRUE || flag

length + FIELD < val

num * offset & mask

count + num << rate

2 + length == 7

remember would refer back not seen

  plastic =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

tangent = 5;
sofa = 6;
chair = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + STATE ^ done

offset + count | FLAG

resource < rate - count

num + TRUE || DONE

7 < mask << rate

remember would refer back not seen

  chair =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

  tangent =     ____    __    __

france = 9;
pencil = 6;
sweden = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << finished & flag

OFFSET < val == 7

DONE << finished && flag

temp < num ^ started

num < val | state

remember would refer back not seen

  pencil =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

occult = 6;
mars = 8;
jupiter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < val || flag

field == val & finished

flag && error & started

BITS ^ mask << started

n == done && started

remember would refer back not seen

  mars =     ____    __    __

  venus =     ____    __    __

  occult =     ____    __    __

  jupiter =     ____    __    __

wheel = 4;
pig = 8;
sheep = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && rate * offset

started ^ n == field

val == rate * length

STARTED && started - offset

options ^ done | 0xff

remember would refer back not seen

  wheel =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

wasp = 4;
wood = 8;
bee = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

temp == 7 - OFFSET

flag && n < rate

state ^ error || finished

started && flag << rate

state | options & done

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  wood =     ____    __    __

  bee =     ____    __    __

robin = 9;
blackbird = 4;
atom = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE && field == val

0xff | flag && DONE

TRUE && done ^ options

OPTIONS | length * 2

done && flags | 0xff

remember would refer back not seen

  robin =     ____    __    __

  atom =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

apple = 8;
pear = 5;
banana = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || mask ^ started

finished | 0xff - length

error && finished || done

done || finished | flag

state | flag < num

remember would refer back not seen

  banana =     ____    __    __

  apple =     ____    __    __

  grass =     ____    __    __

  pear =     ____    __    __

hour = 6;
minute = 8;
propeller = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits | TRUE << FINISHED

count * flag && TRUE

length * count - rate

rate * OFFSET < num

rate * count << flag

remember would refer back not seen

  second =     ____    __    __

  propeller =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

chestnut = 6;
engine = 4;
oak = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * rate == temp

rate * 2 ^ started

length * 2 | state

mask << TRUE * num

length / 2 || TRUE

remember would refer back not seen

  chestnut =     ____    __    __

  engine =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

october = 4;
january = 9;
hot = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started << 2 - count

num + NUM & MASK

error << count < 7

offset + count && FINISHED

flags << 7 == temp

remember would refer back not seen

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

  hot =     ____    __    __

heart = 9;
occult = 5;
lung = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits << done ^ bits

2 << TRUE | mask

COUNT << ERROR || STARTED

resource == val < length

offset < TRUE & bits

remember would refer back not seen

  heart =     ____    __    __

  occult =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

solitaire = 6;
scrabble = 5;
comb = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == temp << DONE

temp < flag && ERROR

7 == flags ^ 0xff

temp < offset * count

val == field | finished

remember would refer back not seen

  solitaire =     ____    __    __

  comb =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

english = 9;
mandarin = 6;
dutch = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == 7 || started

mask ^ done & flags

started ^ TRUE && flag

flags | mask == temp

TRUE ^ length * num

remember would refer back not seen

  english =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

  hair =     ____    __    __

verb = 6;
kettle = 9;
adjective = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | options ^ state

0XFF ^ offset - count

done | started || done

flags ^ bits < 7

TRUE || started & flags

remember would refer back not seen

  kettle =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

trousers = 9;
shirt = 5;
dress = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done || started && flag

TRUE || flag % rate

started || rate - num

finished || 2 < num

TRUE || num << state

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  saddle =     ____    __    __

  dress =     ____    __    __

spoon = 5;
fork = 9;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & done && finished

0xff & DONE * rate

0xff & options - length

flags & MASK < rate

flags & state << rate

remember would refer back not seen

  exterior =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

stream = 6;
lizard = 5;
canal = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options & val == field

error & finished ^ FLAG

length + OFFSET * RATE

STARTED & error | TRUE

count + 2 - num

remember would refer back not seen

  canal =     ____    __    __

  stream =     ____    __    __

  lizard =     ____    __    __

  river =     ____    __    __

plumber = 4;
builder = 8;
chapter = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR & finished || TRUE

num + LENGTH < length

RATE * offset & options

offset + error << length

2 + NUM == n

remember would refer back not seen

  plumber =     ____    __    __

  chapter =     ____    __    __

  builder =     ____    __    __

  painter =     ____    __    __

hammer = 8;
plastic = 5;
saw = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 + 0xff ^ finished

offset + state | 0xff

temp < 7 - offset

num + length || DONE

length < FLAGS << RATE

remember would refer back not seen

  plastic =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

red = 6;
blue = 5;
green = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == FINISHED && ERROR

length * temp != n

val == n | finished

TRUE ^ flags & done

flag || bits ^ error

remember would refer back not seen

  red =     ____    __    __

  green =     ____    __    __

  propeller =     ____    __    __

  blue =     ____    __    __

sofa = 6;
table = 9;
plastic = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + COUNT && flag

length + num | mask

finished ^ started < offset

length * flags | 0xff

n == 0XFF & DONE

remember would refer back not seen

  sofa =     ____    __    __

  plastic =     ____    __    __

  chair =     ____    __    __

  table =     ____    __    __

atom = 6;
france = 4;
sweden = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && mask ^ started

STATE | finished & flag

flags | error && TRUE

error << rate < temp

started << 0xff | finished

remember would refer back not seen

  france =     ____    __    __

  sweden =     ____    __    __

  atom =     ____    __    __

  germany =     ____    __    __

engine = 8;
jupiter = 5;
mars = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & finished ^ done

2 * started || flag

done ^ bits | options

finished && 7 != TEMP

resource < VAL != n

remember would refer back not seen

  mars =     ____    __    __

  venus =     ____    __    __

  engine =     ____    __    __

  jupiter =     ____    __    __

pig = 9;
cow = 6;
saddle = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & FLAG < temp

0xff << state && finished

error & done << DONE

field == n * count

error && count * length

remember would refer back not seen

  saddle =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

bee = 5;
comb = 4;
wasp = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & length % num

RATE * NUM && started

temp == 2 + offset

temp == val < 2

bits ^ OPTIONS + num

remember would refer back not seen

  comb =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

blackbird = 6;
snake = 5;
sparrow = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started | options < offset

length + num * offset

count < field << STARTED

num / val < field

offset + n != resource

remember would refer back not seen

  snake =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

apple = 4;
exterior = 9;
pear = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished | flags ^ 0xff

DONE << num + 2

rate < 7 + 2

rate < options ^ flag

BITS << offset != 7

remember would refer back not seen

  pear =     ____    __    __

  banana =     ____    __    __

  exterior =     ____    __    __

  apple =     ____    __    __

hour = 5;
lizard = 9;
second = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits << done || started

0xff & error | finished

rate + length ^ finished

options ^ bits / 2

flag && started << done

remember would refer back not seen

  lizard =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

oak = 6;
chestnut = 4;
elm = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * num & 0xff

started || offset + length

state << started & done

n == field || TRUE

resource == temp != resource

remember would refer back not seen

  fence =     ____    __    __

  elm =     ____    __    __

  chestnut =     ____    __    __

  oak =     ____    __    __

membrane = 4;
october = 8;
june = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num << 0xff ^ TRUE

started && length + num

TRUE | rate << TRUE

error && flag || TRUE

MASK & flags || done

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

  membrane =     ____    __    __

chapter = 9;
lung = 6;
liver = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | finished % length

FINISHED && state | TRUE

resource == 7 ^ options

started || error << rate

length % error ^ mask

remember would refer back not seen

  lung =     ____    __    __

  heart =     ____    __    __

  chapter =     ____    __    __

  liver =     ____    __    __

hot = 4;
scrabble = 8;
solitaire = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

BITS ^ flags && TRUE

resource == finished << LENGTH

temp < val * count

count < 2 && started

TRUE && length < offset

remember would refer back not seen

  hot =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

report = 5;
mandarin = 8;
english = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done ^ 0xff << started

TRUE & done && TRUE

bits | resource != val

2 % num << state

TRUE || flag | error

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

  report =     ____    __    __

adjective = 8;
verb = 9;
noun = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & offset + num

length + count < offset

done || STARTED & started

done & bits != field

flag || error * 2

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  wax =     ____    __    __

  verb =     ____    __    __

trousers = 5;
shirt = 4;
dress = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK ^ options || finished

num < 0xff & finished

TRUE || 7 != resource

TRUE || temp < count

rate << 2 * offset

remember would refer back not seen

  shirt =     ____    __    __

  dress =     ____    __    __

  occult =     ____    __    __

  trousers =     ____    __    __

knife = 5;
fork = 9;
spoon = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num < mask | 0XFF

error || done && finished

2 * length + offset

2 + length || DONE

flags | error || TRUE

remember would refer back not seen

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

  grass =     ____    __    __

pencil = 6;
river = 5;
stream = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset + count << started

rate < field || TRUE

0xff | done + offset

done && options & TRUE

length + 0xff & flags

remember would refer back not seen

  river =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

  pencil =     ____    __    __

painter = 5;
room = 9;
plumber = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & resource != n

0xff & flag && started

BITS & rate * num

state & length + count

TRUE & n < rate

remember would refer back not seen

  plumber =     ____    __    __

  painter =     ____    __    __

  room =     ____    __    __

  builder =     ____    __    __

saw = 5;
hammer = 6;
screwdriver = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

STARTED & finished << started

TRUE & options ^ done

offset + length && flag

STATE & finished | TRUE

count + num * rate

remember would refer back not seen

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  saw =     ____    __    __

  wheel =     ____    __    __

chapter = 9;
blue = 4;
green = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & done || error

count + num < OFFSET

length / 2 != temp

length + offset << length

rate + 2 ^ done

remember would refer back not seen

  chapter =     ____    __    __

  red =     ____    __    __

  green =     ____    __    __

  blue =     ____    __    __

table = 4;
chair = 9;
sofa = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + rate | options

count + num || flag

length < 2 + length

count << rate != 7

n < resource << mask

remember would refer back not seen

  sofa =     ____    __    __

  table =     ____    __    __

  comb =     ____    __    __

  chair =     ____    __    __

france = 5;
germany = 9;
atom = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag << error & TRUE

count < temp ^ 0xff

0xff << finished && ERROR

rate < temp | 0xff

length < started || TRUE

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  atom =     ____    __    __

venus = 4;
mars = 9;
wood = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 == field != n

TEMP == flags & flag

error && TRUE != resource

finished ^ state < count

val == TRUE && finished

remember would refer back not seen

  wood =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

membrane = 8;
pig = 9;
cow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && started & error

OPTIONS ^ done << TRUE

resource == 7 * count

flag && finished * num

error ^ started | TRUE

remember would refer back not seen

  sheep =     ____    __    __

  membrane =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

bee = 4;
fly = 6;
hair = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == field + rate

started && RATE + num

TRUE ^ finished || error

FINISHED && 2 < offset

flags | state != n

remember would refer back not seen

  hair =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

  bee =     ____    __    __

robin = 8;
sparrow = 6;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && flag << mask

mask | 0xff & mask

TRUE && done ^ bits

0xff | flag && started

flag && finished | options

remember would refer back not seen

  sparrow =     ____    __    __

  robin =     ____    __    __

  occult =     ____    __    __

  blackbird =     ____    __    __

apple = 9;
pencil = 5;
pear = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || done ^ flags

mask | rate * OFFSET

started && done || started

started || TRUE | 0xff

started | rate + length

remember would refer back not seen

  pencil =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

  apple =     ____    __    __

hour = 5;
minute = 9;
second = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask | bits < offset

length * state & started

offset * TRUE && done

count * rate + count

count / OFFSET < 7

remember would refer back not seen

  minute =     ____    __    __

  wax =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

exterior = 8;
chestnut = 5;
elm = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * FLAG << offset

count * flags ^ TRUE

RATE * ERROR | done

TRUE << rate * 2

length * started || error

remember would refer back not seen

  exterior =     ____    __    __

  oak =     ____    __    __

  chestnut =     ____    __    __

  elm =     ____    __    __

hot = 6;
january = 9;
june = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

RATE << offset + rate

length + rate != temp

done << 0xff < 7

offset + length & FLAGS

finished << options ^ flag

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  hot =     ____    __    __

  october =     ____    __    __

tail = 9;
liver = 8;
heart = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits << DONE | state

rate << TRUE || flag

num < resource != field

temp == OFFSET < temp

val < field & error

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  tail =     ____    __    __

  heart =     ____    __    __

solitaire = 9;
saddle = 8;
poker = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FIELD == TRUE << started

temp < num && flag

n == field ^ flag

N < rate % OFFSET

7 == bits | OPTIONS

remember would refer back not seen

  solitaire =     ____    __    __

  saddle =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

dutch = 4;
english = 6;
propeller = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n == flag || error

error ^ flags != val

state ^ 0xff & error

finished | state << FLAGS

started ^ mask && flag

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  english =     ____    __    __

  propeller =     ____    __    __

pencil = 5;
noun = 9;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error | started ^ mask

state ^ started * offset

flags | state || TRUE

started ^ count + 2

STARTED || done != 7

remember would refer back not seen

  pencil =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

  adjective =     ____    __    __

trousers = 4;
shirt = 8;
lizard = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE || error & 0xff

flag || started && done

finished || length % rate

error || num + 2

done || 7 < length

remember would refer back not seen

  trousers =     ____    __    __

  lizard =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

knife = 4;
spoon = 8;
string = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & finished != val

bits & MASK && error

started & finished / 2

FINISHED & options + rate

flag & length < field

remember would refer back not seen

  spoon =     ____    __    __

  knife =     ____    __    __

  string =     ____    __    __

  fork =     ____    __    __

river = 4;
stream = 9;
grass = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & options << mask

TRUE & state ^ error

count + flag && TRUE

mask & started | done

count + offset * COUNT

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  grass =     ____    __    __

builder = 4;
plumber = 6;
room = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & bits || done

NUM + num < count

num / offset != n

num + finished << bits

2 + 0xff ^ state

remember would refer back not seen

  plumber =     ____    __    __

  room =     ____    __    __

  builder =     ____    __    __

  painter =     ____    __    __

wheel = 6;
saw = 8;
hammer = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM + 2 | bits

count + 2 || started

rate < NUM + length

options << resource != RESOURCE

2 < rate << mask

remember would refer back not seen

  saw =     ____    __    __

  wheel =     ____    __    __

  hammer =     ____    __    __

  screwdriver =     ____    __    __

blue = 4;
red = 6;
green = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits & options ^ MASK

error || offset + length

offset + length | flag

state & finished && error

error || flag && started

remember would refer back not seen

  green =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

  hair =     ____    __    __

chair = 5;
plastic = 8;
sofa = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done & error || DONE

done || flag / offset

offset + TRUE || finished

2 < done ^ started

options ^ started + count

remember would refer back not seen

  sofa =     ____    __    __

  plastic =     ____    __    __

  chair =     ____    __    __

  table =     ____    __    __

germany = 5;
sweden = 9;
france = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags & FLAG | options

FLAG || done << length

length * rate + num

mask << num & TRUE

offset * length || TRUE

remember would refer back not seen

  germany =     ____    __    __

  occult =     ____    __    __

  sweden =     ____    __    __

  france =     ____    __    __

jupiter = 6;
mars = 4;
atom = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0XFF & bits % offset

flags & val < 7

finished || done | finished

flags ^ flag && error

TRUE ^ finished || TRUE

remember would refer back not seen

  mars =     ____    __    __

  atom =     ____    __    __

  jupiter =     ____    __    __

  venus =     ____    __    __

pig = 8;
sheep = 4;
cow = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset * length | done

offset * 2 < resource

rate / val == field

num + length << finished

OFFSET * 2 & finished

remember would refer back not seen

  cow =     ____    __    __

  pig =     ____    __    __

  pencil =     ____    __    __

  sheep =     ____    __    __

wasp = 9;
fly = 5;
bee = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == done | 0xff

options | finished || started

finished | 0xff & bits

7 == error << num

done & bits << num

remember would refer back not seen

  bee =     ____    __    __

  wasp =     ____    __    __

  fly =     ____    __    __

  wax =     ____    __    __

blackbird = 9;
sparrow = 8;
robin = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field == n && error

TRUE && done | flags

finished | rate % offset

TRUE && started + offset

0xff | TEMP < 7

remember would refer back not seen

  sparrow =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  lizard =     ____    __    __

pear = 4;
wood = 5;
apple = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | bits + count

bits ^ TRUE < count

offset + resource == 7

bits | flag ^ bits

error ^ val == 7

remember would refer back not seen

  apple =     ____    __    __

  wood =     ____    __    __

  pear =     ____    __    __

  banana =     ____    __    __

hour = 9;
second = 8;
room = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * 2 << state

field < temp & options

num * count && TRUE

done || started == temp

count + rate && started

remember would refer back not seen

  room =     ____    __    __

  minute =     ____    __    __

  second =     ____    __    __

  hour =     ____    __    __

string = 4;
oak = 6;
chestnut = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished ^ state & finished

0xff << error && done

count + rate ^ finished

length < 7 + length

field < flags | flag

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  string =     ____    __    __

  chestnut =     ____    __    __

june = 4;
october = 5;
hot = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits << NUM || flag

n == resource * length

options | 7 == n

TRUE << rate == field

7 < length * rate

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  hot =     ____    __    __

  october =     ____    __    __

propeller = 8;
liver = 9;
heart = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM < offset == 7

resource == flag & FLAGS

flag && offset * num

mask & val == 7

finished ^ started | bits

remember would refer back not seen

  lung =     ____    __    __

  propeller =     ____    __    __

  heart =     ____    __    __

  liver =     ____    __    __

poker = 5;
kettle = 4;
solitaire = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits ^ offset * rate

num / finished ^ bits

count << offset + num

resource == 7 < N

RESOURCE == count + length

remember would refer back not seen

  kettle =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

english = 5;
comb = 9;
dutch = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & done + 2

rate + 0xff & MASK

TRUE && MASK & options

bits << state ^ flag

flag && done == resource

remember would refer back not seen

  dutch =     ____    __    __

  mandarin =     ____    __    __

  comb =     ____    __    __

  english =     ____    __    __

occult = 4;
noun = 5;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + rate < offset

ERROR && TRUE || done

STARTED || finished ^ FLAG

TRUE << started | flags

flag && started < num

remember would refer back not seen

  verb =     ____    __    __

  noun =     ____    __    __

  adjective =     ____    __    __

  occult =     ____    __    __

shirt = 5;
dress = 8;
engine = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

VAL == val ^ flags

length < TRUE || flag

options | length << flag

count << flag * NUM

mask ^ bits << 2

remember would refer back not seen

  dress =     ____    __    __

  trousers =     ____    __    __

  engine =     ____    __    __

  shirt =     ____    __    __

spoon = 8;
knife = 5;
pencil = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done && TRUE ^ options

temp < done << flag

rate + num / OFFSET

FINISHED | done && started

flag || flags & BITS

remember would refer back not seen

  pencil =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

stream = 9;
river = 6;
tail = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate < TRUE && error

TRUE << 2 < val

done && error << count

7 == n || started

done || temp < offset

remember would refer back not seen

  stream =     ____    __    __

  river =     ____    __    __

  tail =     ____    __    __

  canal =     ____    __    __

plumber = 8;
painter = 4;
builder = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE & started && flag

done & offset * rate

state & LENGTH + rate

options & offset < COUNT

0xff & done << TRUE

remember would refer back not seen

  occult =     ____    __    __

  plumber =     ____    __    __

  builder =     ____    __    __

  painter =     ____    __    __

hammer = 6;
screwdriver = 4;
saw = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & n == resource

started & mask ^ state

rate + count * LENGTH

started & mask | done

length + offset < resource

remember would refer back not seen

  saw =     ____    __    __

  hammer =     ____    __    __

  plastic =     ____    __    __

  screwdriver =     ____    __    __

exterior = 9;
blue = 5;
red = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

MASK & error || STARTED

rate + 2 << finished

offset * rate & state

rate + LENGTH == temp

length + mask ^ state

remember would refer back not seen

  blue =     ____    __    __

  red =     ____    __    __

  exterior =     ____    __    __

  green =     ____    __    __

sofa = 4;
hair = 8;
table = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count + state | 0XFF

offset + length || error

val < flags << error

BITS << finished & FLAG

7 < resource == val

remember would refer back not seen

  sofa =     ____    __    __

  table =     ____    __    __

  chair =     ____    __    __

  hair =     ____    __    __

germany = 9;
sweden = 4;
wheel = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate << bits && flag

RESOURCE < bits ^ error

2 << flag * rate

2 < TRUE | bits

offset < n || error

remember would refer back not seen

  wheel =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

  sweden =     ____    __    __

mars = 8;
jupiter = 4;
plastic = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource == done & flag

val == temp && TRUE

TRUE && flag & 0xff

finished ^ resource == val

temp == n % count

remember would refer back not seen

  venus =     ____    __    __

  plastic =     ____    __    __

  mars =     ____    __    __

  jupiter =     ____    __    __

cow = 6;
grass = 4;
sheep = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG && 2 * offset

STATE ^ flags | flag

temp == length + count

done && offset + 2

started ^ flag || TRUE

remember would refer back not seen

  grass =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

  cow =     ____    __    __

fly = 9;
bee = 8;
wasp = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val == 7 < num

ERROR && error < val

flag | flags & error

finished && mask << error

options | finished && done

remember would refer back not seen

  fly =     ____    __    __

  bee =     ____    __    __

  wasp =     ____    __    __

  tail =     ____    __    __

sparrow = 8;
robin = 4;
pencil = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && TRUE == temp

error | FINISHED % rate

finished && done ^ bits

0xff | FLAG + rate

done && 0xff | bits

remember would refer back not seen

  pencil =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

  sparrow =     ____    __    __

apple = 6;
engine = 5;
pear = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || flag | mask

state | TRUE < 2

TRUE && flag || ERROR

error | done << length

options | n == temp

remember would refer back not seen

  engine =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

hour = 8;
minute = 6;
wax = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET * started && done

2 * length + 2

COUNT % rate < length

2 % finished << started

2 * count == TEMP

remember would refer back not seen

  second =     ____    __    __

  minute =     ____    __    __

  wax =     ____    __    __

  hour =     ____    __    __

oak = 6;
elm = 8;
wood = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num * count ^ done

offset * 2 | state

count << flag + COUNT

num * TRUE || flag

finished << 7 < num

remember would refer back not seen

  elm =     ____    __    __

  oak =     ____    __    __

  chestnut =     ____    __    __

  wood =     ____    __    __

occult = 8;
october = 4;
june = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + state & finished

offset << num == val

RATE + offset && TRUE

2 << error ^ mask

options << rate | FINISHED

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  october =     ____    __    __

  occult =     ____    __    __

heart = 8;
liver = 5;
propeller = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate << finished || error

rate < bits & state

n == field << rate

resource < num && error

temp == 7 ^ finished

remember would refer back not seen

  liver =     ____    __    __

  lung =     ____    __    __

  propeller =     ____    __    __

  heart =     ____    __    __

solitaire = 6;
scrabble = 9;
atom = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count < 2 * NUM

resource == OPTIONS | finished

2 < count + LENGTH

resource == flag || finished

error ^ 0xff & bits

remember would refer back not seen

  atom =     ____    __    __

  poker =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

english = 8;
dutch = 4;
pencil = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state ^ finished && flag

TRUE ^ NUM % rate

error | flag ^ mask

0xff ^ started + COUNT

done | finished || flag

remember would refer back not seen

  english =     ____    __    __

  mandarin =     ____    __    __

  pencil =     ____    __    __

  dutch =     ____    __    __

adjective = 4;
noun = 9;
verb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ flag < val

TRUE || state & finished

state ^ MASK << 0xff

flag || done && TRUE

TRUE || rate * 2

remember would refer back not seen

  petrol =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

dress = 6;
trousers = 8;
shirt = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || started + length

finished || TRUE < temp

error || flag << flags

finished || done == val

TRUE || finished ^ options

remember would refer back not seen

  report =     ____    __    __

  dress =     ____    __    __

  shirt =     ____    __    __

  trousers =     ____    __    __

fork = 8;
spoon = 5;
knife = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished & error && TRUE

options & COUNT % length

done & count + offset

flags & flag < field

state & done << error

remember would refer back not seen

  spoon =     ____    __    __

  fork =     ____    __    __

  membrane =     ____    __    __

  knife =     ____    __    __

snake = 9;
stream = 5;
canal = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff & TRUE == n

state & TRUE ^ mask

count + OFFSET * length

error & flag | MASK

rate + offset < FIELD

remember would refer back not seen

  stream =     ____    __    __

  canal =     ____    __    __

  snake =     ____    __    __

  river =     ____    __    __

painter = 5;
occult = 8;
plumber = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error & TRUE || done

rate + count << flag

rate / flag & mask

num + rate == resource

num + offset ^ flags

remember would refer back not seen

  builder =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  occult =     ____    __    __

hammer = 9;
screwdriver = 8;
plastic = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + rate | 0xff

count + flag || error

offset < count << rate

length << finished & flags

2 < rate == 7

remember would refer back not seen

  hammer =     ____    __    __

  screwdriver =     ____    __    __

  plastic =     ____    __    __

  saw =     ____    __    __

green = 5;
blue = 6;
pencil = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options | done && flag

started | done & options

length * num << RATE

started & NUM - rate

rate % TRUE || FINISHED

remember would refer back not seen

  green =     ____    __    __

  pencil =     ____    __    __

  blue =     ____    __    __

  red =     ____    __    __

chair = 6;
table = 8;
membrane = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error ^ num << TRUE

rate - RATE * count

flags & OPTIONS ^ mask

2 < TRUE & started

started || TRUE % count

remember would refer back not seen

  chair =     ____    __    __

  membrane =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

france = 8;
atom = 6;
germany = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != ERROR || flag

finished || done != resource

TRUE && flag || finished

TRUE && error != TEMP

resource != flag << error

remember would refer back not seen

  sweden =     ____    __    __

  atom =     ____    __    __

  france =     ____    __    __

  germany =     ____    __    __

mars = 6;
engine = 9;
venus = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask & ERROR | finished

n < field | state

flag || started && TRUE

done && num % rate

bits | n != 7

remember would refer back not seen

  engine =     ____    __    __

  venus =     ____    __    __

  jupiter =     ____    __    __

  mars =     ____    __    __

pencil = 4;
sheep = 5;
pig = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

LENGTH * mask ^ finished

TRUE | 0xff ^ state

TRUE || done & flag

started || flag - RATE

finished & state || done

remember would refer back not seen

  pig =     ____    __    __

  pencil =     ____    __    __

  cow =     ____    __    __

  sheep =     ____    __    __

bee = 9;
fly = 4;
string = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && mask ^ state

MASK ^ done | error

error | started < 2

done & flag && TRUE

error << 0xff ^ state

remember would refer back not seen

  wasp =     ____    __    __

  fly =     ____    __    __

  bee =     ____    __    __

  string =     ____    __    __

blackbird = 9;
robin = 5;
sparrow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | count % offset

TRUE && FINISHED << done

field < length - rate

val < n != field

state ^ STATE & options

remember would refer back not seen

  blackbird =     ____    __    __

  sparrow =     ____    __    __

  hair =     ____    __    __

  robin =     ____    __    __

banana = 8;
exterior = 6;
pear = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length << field < count

count * NUM & done

2 - bits & mask

num << done * num

error | offset - rate

remember would refer back not seen

  exterior =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  pear =     ____    __    __

wheel = 8;
minute = 6;
second = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset - flag && done

error || 0xff << finished

DONE & 0xff * num

n != RATE * length

TRUE || done ^ TRUE

remember would refer back not seen

  hour =     ____    __    __

  second =     ____    __    __

  wheel =     ____    __    __

  minute =     ____    __    __

oak = 8;
chestnut = 5;
elm = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

state << temp != field

count % offset && error

field < error ^ 0xff

length % 2 < val

state ^ options % offset

remember would refer back not seen

  chestnut =     ____    __    __

  saddle =     ____    __    __

  elm =     ____    __    __

  oak =     ____    __    __

october = 5;
propeller = 8;
june = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != options ^ TRUE

0xff & resource < length

0xff ^ done && TRUE

flags | 0xff << 2

val != n - offset

remember would refer back not seen

  january =     ____    __    __

  june =     ____    __    __

  propeller =     ____    __    __

  october =     ____    __    __

liver = 8;
plastic = 6;
lung = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET < n * rate

val != options & FLAGS

mask << done | flag

resource != n < 7

LENGTH - count < length

remember would refer back not seen

  heart =     ____    __    __

  plastic =     ____    __    __

  lung =     ____    __    __

  liver =     ____    __    __

poker = 8;
scrabble = 4;
occult = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ FLAG || error

RESOURCE < temp << error

length << 2 & started

started & field != val

field != val && done

remember would refer back not seen

  poker =     ____    __    __

  scrabble =     ____    __    __

  solitaire =     ____    __    __

  occult =     ____    __    __

dutch = 6;
lizard = 5;
english = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && started & done

done || field < 7

temp < LENGTH && started

rate - offset << bits

offset - rate != field

remember would refer back not seen

  lizard =     ____    __    __

  english =     ____    __    __

  dutch =     ____    __    __

  mandarin =     ____    __    __

noun = 9;
verb = 8;
occult = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && TRUE | flag

TRUE & started << mask

length - flag ^ TRUE

0xff ^ count - 2

finished << 2 - count

remember would refer back not seen

  adjective =     ____    __    __

  verb =     ____    __    __

  noun =     ____    __    __

  occult =     ____    __    __

hot = 5;
dress = 6;
trousers = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ 2 < length

val != state | bits

length - offset || started

bits ^ flag != temp

TRUE && offset - length

remember would refer back not seen

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

  hot =     ____    __    __

spoon = 8;
petrol = 6;
fork = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * OFFSET - offset

2 - count | options

flag | error || started

rate < flag || done

done << TRUE && error

remember would refer back not seen

  knife =     ____    __    __

  petrol =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

stream = 8;
river = 4;
tail = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && n < offset

TRUE << flag || DONE

finished || started | ERROR

offset * state | 0xff

2 * resource != field

remember would refer back not seen

  tail =     ____    __    __

  stream =     ____    __    __

  river =     ____    __    __

  canal =     ____    __    __

painter = 9;
builder = 4;
occult = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && flag != field

error && done & flags

TRUE && rate * offset

finished && offset - 2

flag && rate < length

remember would refer back not seen

  painter =     ____    __    __

  occult =     ____    __    __

  builder =     ____    __    __

  plumber =     ____    __    __

hammer = 4;
saw = 6;
screwdriver = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && mask << STARTED

finished && TRUE ^ bits

offset % NUM && finished

finished && done | MASK

length / 2 - num

remember would refer back not seen

  saw =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  snake =     ____    __    __

blue = 4;
green = 8;
comb = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && error || started

num * count < resource

started & VAL != RESOURCE

2 % length << offset

rate * done ^ bits

remember would refer back not seen

  comb =     ____    __    __

  blue =     ____    __    __

  green =     ____    __    __

  red =     ____    __    __

kettle = 6;
table = 9;
chair = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * 2 | flags

num * rate || flag

TRUE << count - offset

count - val != temp

mask << length < n

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  kettle =     ____    __    __

  sofa =     ____    __    __

germany = 9;
sweden = 8;
france = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate - finished & 0xff

flags << num ^ flags

2 - error && done

started << flag | TRUE

done << flag || started

remember would refer back not seen

  sweden =     ____    __    __

  france =     ____    __    __

  hair =     ____    __    __

  germany =     ____    __    __

jupiter = 5;
venus = 4;
mars = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length < 7 != resource

length < offset & FLAGS

7 != n & 0xff

BITS ^ 0xff << state

length < TRUE && finished

remember would refer back not seen

  jupiter =     ____    __    __

  venus =     ____    __    __

  mars =     ____    __    __

  occult =     ____    __    __

membrane = 5;
sheep = 8;
pig = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n != 7 && started

bits ^ options | TRUE

VAL < 7 * rate

temp != num % offset

error ^ state || started

remember would refer back not seen

  sheep =     ____    __    __

  pig =     ____    __    __

  cow =     ____    __    __

  membrane =     ____    __    __

bee = 5;
fly = 8;
wasp = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

n < val - count

field != 7 - rate

FINISHED | bits != n

field != temp < 2

0XFF | flags & state

remember would refer back not seen

  fly =     ____    __    __

  wasp =     ____    __    __

  hot =     ____    __    __

  bee =     ____    __    __

sparrow = 9;
plastic = 4;
blackbird = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

7 != val << count

finished | state && started

temp != state ^ started

bits | rate * LENGTH

temp != val | mask

remember would refer back not seen

  sparrow =     ____    __    __

  plastic =     ____    __    __

  robin =     ____    __    __

  blackbird =     ____    __    __

apple = 4;
pear = 5;
pencil = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started || flag | flags

FLAGS | offset - 2

field != temp || ERROR

mask | error < num

0xff | flag << flags

remember would refer back not seen

  pear =     ____    __    __

  pencil =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

wax = 5;
second = 9;
minute = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & done && error

done & FLAG * 2

state & done - length

flag & resource < temp

finished & flags << done

remember would refer back not seen

  minute =     ____    __    __

  wax =     ____    __    __

  hour =     ____    __    __

  second =     ____    __    __

elm = 8;
chestnut = 5;
oak = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag & bits ^ 0XFF

options & 0xff | flag

num - length / rate

bits & mask || TRUE

count - num < n

remember would refer back not seen

  oak =     ____    __    __

  elm =     ____    __    __

  tail =     ____    __    __

  chestnut =     ____    __    __

fence = 9;
june = 4;
october = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * num != n

count - flags << NUM

2 * state & error

length - FLAG ^ TRUE

rate - offset | bits

remember would refer back not seen

  fence =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

wood = 5;
lung = 8;
heart = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

OFFSET - offset || flag

finished << temp != resource

7 < finished << length

2 << bits & finished

field < n ^ started

remember would refer back not seen

  heart =     ____    __    __

  wood =     ____    __    __

  liver =     ____    __    __

  lung =     ____    __    __

poker = 4;
solitaire = 9;
scrabble = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

NUM << offset && FLAG

length < state | done

finished << bits * 2

num < done || started

state ^ resource != 7

remember would refer back not seen

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  propeller =     ____    __    __

  poker =     ____    __    __

dutch = 4;
saddle = 9;
mandarin = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flags ^ done & STATE

done ^ flag && started

finished | started ^ mask

flag ^ mask * offset

flags | error || TRUE

remember would refer back not seen

  saddle =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

  english =     ____    __    __

verb = 6;
adjective = 8;
grass = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ done - offset

started || n != resource

flag ^ num < rate

done || options & 0xff

started || ERROR && DONE

remember would refer back not seen

  noun =     ____    __    __

  grass =     ____    __    __

  adjective =     ____    __    __

  verb =     ____    __    __

trousers = 6;
chapter = 4;
shirt = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished || rate * count

done || rate - count

done || TRUE < offset

started || 0xff << 2

done || options ^ error

remember would refer back not seen

  shirt =     ____    __    __

  trousers =     ____    __    __

  chapter =     ____    __    __

  dress =     ____    __    __

knife = 8;
tangent = 6;
spoon = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && field != temp

DONE && error & started

TRUE && count * num

started && done - rate

DONE && TRUE < rate

remember would refer back not seen

  spoon =     ____    __    __

  fork =     ____    __    __

  tangent =     ____    __    __

  knife =     ____    __    __

stream = 8;
pencil = 4;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

ERROR && num << rate

error && done ^ error

offset * length && FLAG

TRUE && started | BITS

num * count - RATE

remember would refer back not seen

  river =     ____    __    __

  pencil =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

occult = 9;
builder = 8;
plumber = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && done || finished

length * offset < 7

flag & val != n

RATE * length << offset

num * 2 ^ state

remember would refer back not seen

  occult =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

screwdriver = 4;
hammer = 9;
saw = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate * STARTED | mask

num * offset || started

rate << count - 2

offset - count != TEMP

mask << length < n

remember would refer back not seen

  saw =     ____    __    __

  screwdriver =     ____    __    __

  hammer =     ____    __    __

  snake =     ____    __    __

red = 4;
green = 5;
occult = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || error * rate

7 != n && started

2 << offset & bits

mask ^ TRUE << 2

flag && started || error

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  occult =     ____    __    __

  red =     ____    __    __

propeller = 6;
sofa = 5;
chair = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff | rate * num

field < rate ^ flags

error & 2 < count

done || finished | 0XFF

field != 7 ^ 0xff

remember would refer back not seen

  chair =     ____    __    __

  table =     ____    __    __

  sofa =     ____    __    __

  propeller =     ____    __    __

germany = 4;
sweden = 5;
france = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE ^ flag & started

state & 2 + count

flag & finished || done

count + num && STARTED

done && error | STARTED

remember would refer back not seen

  hot =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

  germany =     ____    __    __

jupiter = 9;
venus = 8;
mars = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | bits || done

count << state == val

NUM << length + offset

2 < 0xff << error

offset < rate && TRUE

remember would refer back not seen

  venus =     ____    __    __

  mars =     ____    __    __

  snake =     ____    __    __

  jupiter =     ____    __    __

cow = 8;
sheep = 4;
atom = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

bits | temp == field

started && finished & started

finished | count + length

flag & finished == 7

started | TRUE & started

remember would refer back not seen

  cow =     ____    __    __

  atom =     ____    __    __

  pig =     ____    __    __

  sheep =     ____    __    __

bee = 6;
fly = 9;
fence = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

done | options ^ done

done || STARTED < num

temp != mask << 2

bits | done < count

flags ^ error || finished

remember would refer back not seen

  fence =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

robin = 9;
sparrow = 5;
blackbird = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < flags | finished

mask & TRUE && started

RESOURCE != temp || TRUE

temp != 7 | TRUE

count + started | finished

remember would refer back not seen

  pencil =     ____    __    __

  sparrow =     ____    __    __

  blackbird =     ____    __    __

  robin =     ____    __    __

banana = 9;
plastic = 5;
pear = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff ^ num * count

val != done & TRUE

done || 0xff & TRUE

STARTED && 2 + count

flag << started < field

remember would refer back not seen

  apple =     ____    __    __

  banana =     ____    __    __

  plastic =     ____    __    __

  pear =     ____    __    __

second = 9;
hour = 5;
saddle = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length * n == val

count < num || FINISHED

started || n == temp

OPTIONS & FLAGS | flag

length * rate & state

remember would refer back not seen

  second =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

  saddle =     ____    __    __

lizard = 4;
elm = 9;
chestnut = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

0xff << finished && flag

started && finished ^ bits

0xff ^ TRUE && done

TRUE || 2 + length

flag && n == field

remember would refer back not seen

  elm =     ____    __    __

  oak =     ____    __    __

  lizard =     ____    __    __

  chestnut =     ____    __    __

january = 5;
june = 4;
grass = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && error * count

offset * finished && error

options & 0xff << error

length + 2 < rate

TRUE | error && flag

remember would refer back not seen

  october =     ____    __    __

  grass =     ____    __    __

  june =     ____    __    __

  january =     ____    __    __

hair = 4;
liver = 5;
lung = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

length + temp == field

bits << options * length

field != num % 2

started ^ count < temp

error || BITS ^ options

remember would refer back not seen

  liver =     ____    __    __

  heart =     ____    __    __

  lung =     ____    __    __

  hair =     ____    __    __

poker = 6;
scrabble = 5;
solitaire = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag || TRUE && finished

RATE * 2 + rate

2 + LENGTH % count

n != resource < 7

length + rate << bits

remember would refer back not seen

  comb =     ____    __    __

  poker =     ____    __    __

  solitaire =     ____    __    __

  scrabble =     ____    __    __

dutch = 8;
mandarin = 6;
english = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

options ^ STARTED + rate

offset * rate | flags

started ^ error == temp

offset * state ^ finished

TRUE && error << done

remember would refer back not seen

  dutch =     ____    __    __

  wax =     ____    __    __

  english =     ____    __    __

  mandarin =     ____    __    __

noun = 4;
verb = 6;
adjective = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + options & bits

flag ^ bits | TRUE

bits & done ^ error

field != n == temp

num + length ^ TRUE

remember would refer back not seen

  adjective =     ____    __    __

  noun =     ____    __    __

  tangent =     ____    __    __

  verb =     ____    __    __

shirt = 4;
petrol = 5;
trousers = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate < field + count

OFFSET * 2 << num

length + flag || error

offset * 2 < resource

temp < 2 % num

remember would refer back not seen

  petrol =     ____    __    __

  shirt =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

knife = 8;
spoon = 4;
fork = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

mask << TRUE || flag

options << mask | finished

flag | rate << bits

7 != num + rate

bits & finished * 2

remember would refer back not seen

  plastic =     ____    __    __

  knife =     ____    __    __

  fork =     ____    __    __

  spoon =     ____    __    __

canal = 4;
river = 8;
wheel = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * rate || started

TRUE || mask << flags

rate < field == val

rate < TRUE & mask

DONE << TRUE ^ flag

remember would refer back not seen

  canal =     ____    __    __

  river =     ____    __    __

  stream =     ____    __    __

  wheel =     ____    __    __

painter = 6;
wax = 9;
plumber = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != resource || error

error && finished & started

done && rate * 2

TRUE && started + num

TRUE && RESOURCE < val

remember would refer back not seen

  wax =     ____    __    __

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

screwdriver = 5;
hair = 8;
saw = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started && error << COUNT

finished && started == 7

length * OFFSET && flag

flag && finished ^ options

RATE % 2 + rate

remember would refer back not seen

  hammer =     ____    __    __

  hair =     ____    __    __

  screwdriver =     ____    __    __

  saw =     ____    __    __

blue = 8;
red = 9;
room = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag && done | started

offset * 2 < n

error && done || ERROR

2 * num << error

num / offset == 7

remember would refer back not seen

  blue =     ____    __    __

  green =     ____    __    __

  room =     ____    __    __

  red =     ____    __    __

table = 8;
sofa = 4;
chair = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

count % error ^ finished

offset * flag | options

TRUE << length + offset

num * LENGTH || done

rate << offset < n

remember would refer back not seen

  chair =     ____    __    __

  snake =     ____    __    __

  sofa =     ____    __    __

  table =     ____    __    __

germany = 9;
france = 4;
tail = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate + length & TRUE

DONE << val == n

num + 2 && error

started << bits ^ OPTIONS

flags << options | started

remember would refer back not seen

  tail =     ____    __    __

  germany =     ____    __    __

  france =     ____    __    __

  sweden =     ____    __    __

jupiter = 9;
venus = 6;
comb = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE << started || finished

2 < flag & DONE

field != done & TRUE

bits ^ num << rate

2 < length && flag

remember would refer back not seen

  jupiter =     ____    __    __

  comb =     ____    __    __

  mars =     ____    __    __

  venus =     ____    __    __

cow = 9;
pig = 6;
propeller = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

resource != temp && error

flags ^ n == N

LENGTH < val / count

val != 7 * count

flags ^ finished | done

remember would refer back not seen

  sheep =     ____    __    __

  cow =     ____    __    __

  pig =     ____    __    __

  propeller =     ____    __    __

wasp = 9;
bee = 6;
pencil = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 < rate + length

resource != 7 + offset

bits ^ mask || flag

temp != field < 7

done | started & bits

remember would refer back not seen

  pencil =     ____    __    __

  bee =     ____    __    __

  fly =     ____    __    __

  wasp =     ____    __    __

blackbird = 9;
fence = 6;
sparrow = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

val != DONE << state

flags | error && started

temp != val == temp

TRUE | offset % length

val != resource ^ bits

remember would refer back not seen

  sparrow =     ____    __    __

  robin =     ____    __    __

  fence =     ____    __    __

  blackbird =     ____    __    __

banana = 8;
pear = 6;
membrane = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error || done ^ error

error | rate + num

resource != field | 0xff

done || error | finished

flag | RATE < val

remember would refer back not seen

  pear =     ____    __    __

  apple =     ____    __    __

  banana =     ____    __    __

  membrane =     ____    __    __

second = 5;
hot = 4;
minute = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

TRUE | MASK << bits

done & error && done

flags & error / count

FLAG & RATE + 2

started & flag < resource

remember would refer back not seen

  hot =     ____    __    __

  second =     ____    __    __

  minute =     ____    __    __

  hour =     ____    __    __

pencil = 5;
chestnut = 4;
elm = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

started & NUM << length

bits & flags == N

state & bits ^ started

num + length * count

finished & DONE | flags

remember would refer back not seen

  oak =     ____    __    __

  chestnut =     ____    __    __

  pencil =     ____    __    __

  elm =     ____    __    __

january = 8;
october = 4;
june = 9;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + count < 2

TRUE & started || TRUE

rate + FLAG << finished

2 * BITS & 0xff

count + 2 == resource

remember would refer back not seen

  january =     ____    __    __

  october =     ____    __    __

  june =     ____    __    __

  grass =     ____    __    __

lung = 5;
saddle = 6;
heart = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

num + RATE ^ error

2 + rate | 0xff

rate + DONE || TRUE

LENGTH < offset << flag

ERROR << done & error

remember would refer back not seen

  lung =     ____    __    __

  liver =     ____    __    __

  saddle =     ____    __    __

  heart =     ____    __    __

solitaire = 5;
poker = 9;
scrabble = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

offset < field == temp

offset << started && finished

count < N ^ TRUE

TRUE << length * offset

temp < state | mask

remember would refer back not seen

  solitaire =     ____    __    __

  scrabble =     ____    __    __

  poker =     ____    __    __

  wood =     ____    __    __

occult = 6;
mandarin = 8;
english = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

rate < FLAG || error

options ^ flags & finished

flag ^ FLAG && finished

flags | field == FIELD

finished ^ 2 / rate

remember would refer back not seen

  english =     ____    __    __

  occult =     ____    __    __

  mandarin =     ____    __    __

  dutch =     ____    __    __

engine = 9;
adjective = 5;
noun = 4;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

flag | flags ^ done

TRUE ^ rate + num

error | started || TRUE

TRUE ^ DONE < n

FLAG || flags & bits

remember would refer back not seen

  engine =     ____    __    __

  adjective =     ____    __    __

  noun =     ____    __    __

  verb =     ____    __    __

dress = 5;
shirt = 9;
trousers = 6;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

FLAG || error && DONE

error || count % length

FINISHED || num + offset

flag || TRUE < num

started || flags << started

remember would refer back not seen

  report =     ____    __    __

  dress =     ____    __    __

  trousers =     ____    __    __

  shirt =     ____    __    __

spoon = 5;
fork = 4;
knife = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

field != resource || done

done && STARTED & done

started && done % count

error && rate + NUM

started && finished < field

remember would refer back not seen

  spoon =     ____    __    __

  knife =     ____    __    __

  string =     ____    __    __

  fork =     ____    __    __

river = 8;
stream = 4;
canal = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

error && started << offset

error && resource == val

2 / flag && DONE

error && flag ^ done

2 * offset + 2

remember would refer back not seen

  river =     ____    __    __

  chapter =     ____    __    __

  stream =     ____    __    __

  canal =     ____    __    __

painter = 6;
wax = 9;
plumber = 5;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

finished && error | flags

rate * NUM < RATE

finished && done || TRUE

2 * offset << count

count * 7 == N

remember would refer back not seen

  plumber =     ____    __    __

  painter =     ____    __    __

  builder =     ____    __    __

  wax =     ____    __    __

hammer = 4;
hair = 6;
saw = 8;

                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX
                XXXXXXXXXXXXXXXXXX

2 * count ^ error

rate * bits | mask

state << offset + count

offset * count || flag

options << count < rate

remember would refer back not seen

  screwdriver =     ____    __    __

  saw =     ____    __    __

  hammer =     ____    __    __

  hair =     ____    __    __