RLang: Policy : \n \t if a <= y : \n \t \t Execute find \n
English: you can try attempt to find if a is smaller than or the same as y

RLang: Policy : \n \t if position > y : \n \t \t Execute search \n elif position == y : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: it would be advantageous to try to search if position is greater than y otherwise, if position is exactly the same as y attempt to search , or attempt to search otherwise

RLang: Policy collect_wood := \n \t if a > z : \n \t \t Execute run \n elif a == z : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: collect_wood means that it would be good to attempt to run if a is larger than z otherwise, if a is exactly the same as z try to run , or aim to run if not

RLang: Policy build_bridge := \n \t if a > x : \n \t \t Execute use \n elif a != x : \n \t \t Execute use \n elif a <= x : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: build_bridge is an approach where you try to use if a is larger than x otherwise, if a is not the same as x attempt to use otherwise, if a is less than or the same as x try to use , or aim to use otherwise

RLang: Policy : \n \t if inventory == y : \n \t \t Execute walk \n elif inventory > y : \n \t \t Execute walk \n elif inventory == y : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: you can aim to walk if inventory is equal to y otherwise, if inventory is greater than y aim to walk otherwise, if inventory is equal to y  walk , or  walk if not

RLang: Policy : \n \t if c == z : \n \t \t Execute walk \n elif z : \n \t \t Execute walk \n elif c != z : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: it would be advantageous to  walk if c is equal to z otherwise, if z  walk otherwise, if c is not equal to z aim to walk , or  walk as a last resort

RLang: Policy : \n \t if a == z : \n \t \t Execute run \n elif a >= z : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: it is a good idea if you  run if a is exactly the same as z otherwise, if a is greater than or equal to z try to run , or  run if not

RLang: Policy do_something := \n \t if inventory <= z : \n \t \t Execute find \n elif inventory != z : \n \t \t Execute find \n elif inventory < z : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: do_something is an approach where you aim to find if inventory is less than or equal to z otherwise, if inventory is not equal to z aim to find otherwise, if inventory is less than z aim to find , or aim to find if not

RLang: Policy : \n \t if a : \n \t \t Execute build \n elif a <= z : \n \t \t Execute build \n elif a >= z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: it would be advantageous to attempt to build if a otherwise, if a is smaller than or the same as z  build otherwise, if a is greater than or the same as z try to build , or aim to build as a last resort

RLang: Policy build_bridge := \n \t if a >= x : \n \t \t Execute find \n elif a < x : \n \t \t Execute find \n elif a >= x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: build_bridge is a tactic where it is advantageous to  find if a is greater than or equal to x otherwise, if a is smaller than x attempt to find otherwise, if a is greater than or the same as x  find , or aim to find if no other options are possible

RLang: Policy : \n \t if a < z : \n \t \t Execute jump \n elif a == z : \n \t \t Execute jump \n elif a == z : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: you can  jump if a is smaller than z otherwise, if a is exactly the same as z try to jump otherwise, if a is equal to z aim to jump , or attempt to jump otherwise

RLang: Policy do_something := \n \t if inventory < x : \n \t \t Execute find \n elif inventory < x : \n \t \t Execute find \n elif inventory < x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: do_something means that it would be good to attempt to find if inventory is less than x otherwise, if inventory is less than x aim to find otherwise, if inventory is less than x try to find , or aim to find if no other options are possible

RLang: Policy : \n \t if c == x : \n \t \t Execute run \n elif c < x : \n \t \t Execute run \n elif c == x : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: you should try to run if c is exactly the same as x otherwise, if c is less than x aim to run otherwise, if c is equal to x  run , or  run otherwise

RLang: Policy do_the_thing := \n \t if b == y : \n \t \t Execute jump \n elif b <= y : \n \t \t Execute jump \n elif b != y : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: do_the_thing is a strategy where you attempt to jump if b is equal to y otherwise, if b is smaller than or equal to y aim to jump otherwise, if b is not the same as y try to jump , or try to jump if not

RLang: Policy do_the_thing := \n \t if a > x : \n \t \t Execute use \n elif a >= x : \n \t \t Execute use \n elif a == x : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: do_the_thing entails that you aim to use if a is greater than x otherwise, if a is greater than or the same as x aim to use otherwise, if a is equal to x  use , or attempt to use if no other options are possible

RLang: Policy collect_wood := \n \t if a == z : \n \t \t Execute jump \n elif a <= z : \n \t \t Execute jump \n elif a < z : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: collect_wood is a strategy where you  jump if a is equal to z otherwise, if a is smaller than or the same as z try to jump otherwise, if a is less than z aim to jump , or attempt to jump if no other options are possible

RLang: Policy : \n \t if c >= x : \n \t \t Execute find \n elif c >= x : \n \t \t Execute find \n elif c <= x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: it is a good idea if you attempt to find if c is larger than or the same as x otherwise, if c is greater than or equal to x try to find otherwise, if c is less than or equal to x attempt to find , or  find if not

RLang: Policy collect_wood := \n \t if c : \n \t \t Execute jump \n elif c <= x : \n \t \t Execute jump \n elif c < x : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: collect_wood is an approach where you try to jump if c otherwise, if c is smaller than or the same as x attempt to jump otherwise, if c is smaller than x  jump , or aim to jump otherwise

RLang: Policy : \n \t if b < y : \n \t \t Execute use \n elif b >= y : \n \t \t Execute use \n elif b > y : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: you should  use if b is smaller than y otherwise, if b is larger than or equal to y attempt to use otherwise, if b is larger than y try to use , or try to use if no other options are possible

RLang: Policy collect_wood := \n \t if a > x : \n \t \t Execute search \n elif a == x : \n \t \t Execute search \n elif a < x : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: collect_wood suggests that it would be advantageous to aim to search if a is larger than x otherwise, if a is exactly the same as x attempt to search otherwise, if a is smaller than x attempt to search , or attempt to search if no other options are possible

RLang: Policy : \n \t if c != y : \n \t \t Execute run \n elif y : \n \t \t Execute run \n elif c < y : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: you can try try to run if c is not equal to y otherwise, if y attempt to run otherwise, if c is smaller than y  run , or  run otherwise

RLang: Policy : \n \t if a <= y : \n \t \t Execute use \n elif a <= y : \n \t \t Execute use \n elif a >= y : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: it would be advantageous to  use if a is smaller than or the same as y otherwise, if a is less than or equal to y  use otherwise, if a is greater than or the same as y  use , or try to use if not

RLang: Policy : \n \t if position < x : \n \t \t Execute walk \n elif position > x : \n \t \t Execute walk \n elif x : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: you can aim to walk if position is smaller than x otherwise, if position is greater than x aim to walk otherwise, if x  walk , or aim to walk otherwise

RLang: Policy cross_the_street := \n \t if a == y : \n \t \t Execute find \n elif a >= y : \n \t \t Execute find \n elif a < y : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: cross_the_street is a strategy where you aim to find if a is equal to y otherwise, if a is larger than or the same as y aim to find otherwise, if a is smaller than y  find , or try to find if not

RLang: Policy do_the_thing := \n \t if c <= z : \n \t \t Execute build \n elif c < z : \n \t \t Execute build \n elif c > z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: do_the_thing is a strategy where you aim to build if c is less than or the same as z otherwise, if c is smaller than z  build otherwise, if c is larger than z  build , or aim to build if not

RLang: Policy do_the_thing := \n \t if inventory : \n \t \t Execute walk \n elif inventory >= z : \n \t \t Execute walk \n elif inventory == z : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: do_the_thing is a tactic where it is advantageous to attempt to walk if inventory otherwise, if inventory is greater than or the same as z attempt to walk otherwise, if inventory is equal to z attempt to walk , or try to walk otherwise

RLang: Policy : \n \t if b >= x : \n \t \t Execute find \n elif b != x : \n \t \t Execute find \n elif b <= x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: it is a good idea for you  find if b is greater than or the same as x otherwise, if b is not equal to x  find otherwise, if b is smaller than or the same as x try to find , or attempt to find if not

RLang: Policy build_bridge := \n \t if b : \n \t \t Execute search \n elif b != y : \n \t \t Execute search \n elif b != y : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: build_bridge is a good strategy where you should  search if b otherwise, if b is not the same as y aim to search otherwise, if b is not the same as y aim to search , or try to search as a last resort

RLang: Policy : \n \t if inventory <= y : \n \t \t Execute run \n elif inventory != y : \n \t \t Execute run \n elif inventory > y : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: it is a good idea for you attempt to run if inventory is less than or the same as y otherwise, if inventory is not equal to y try to run otherwise, if inventory is larger than y aim to run , or aim to run if no other options are possible

RLang: Policy collect_wood := \n \t if a <= z : \n \t \t Execute find \n elif a >= z : \n \t \t Execute find \n elif a > z : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: collect_wood is an approach where it would be good to try to find if a is smaller than or the same as z otherwise, if a is greater than or the same as z attempt to find otherwise, if a is larger than z attempt to find , or  find otherwise

RLang: Policy : \n \t if b : \n \t \t Execute run \n elif b <= x : \n \t \t Execute run \n elif b == x : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: it is a good idea if you try to run if b otherwise, if b is less than or equal to x aim to run otherwise, if b is exactly the same as x attempt to run , or try to run otherwise

RLang: Policy : \n \t if c != z : \n \t \t Execute walk \n elif c > z : \n \t \t Execute walk \n elif c > z : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: you can try aim to walk if c is not equal to z otherwise, if c is greater than z  walk otherwise, if c is larger than z try to walk , or try to walk if no other options are possible

RLang: Policy do_the_thing := \n \t if position : \n \t \t Execute build \n elif position >= z : \n \t \t Execute build \n elif position < z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: do_the_thing is an approach where it would be good to try to build if position otherwise, if position is greater than or the same as z try to build otherwise, if position is less than z aim to build , or aim to build if no other options are possible

RLang: Policy build_bridge := \n \t if inventory >= y : \n \t \t Execute jump \n elif inventory < y : \n \t \t Execute jump \n elif inventory != y : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: build_bridge entails that you attempt to jump if inventory is larger than or the same as y otherwise, if inventory is smaller than y attempt to jump otherwise, if inventory is not the same as y attempt to jump , or  jump as a last resort

RLang: Policy : \n \t if c >= x : \n \t \t Execute walk \n elif c != x : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: you should try to walk if c is greater than or the same as x otherwise, if c is not equal to x try to walk , or attempt to walk if not

RLang: Policy build_bridge := \n \t if b <= y : \n \t \t Execute jump \n elif b > y : \n \t \t Execute jump \n elif b < y : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: build_bridge is a good strategy where you should try to jump if b is smaller than or equal to y otherwise, if b is greater than y  jump otherwise, if b is smaller than y attempt to jump , or  jump if no other options are possible

RLang: Policy : \n \t if inventory < z : \n \t \t Execute use \n elif inventory <= z : \n \t \t Execute use \n elif inventory < z : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: it would be advantageous to try to use if inventory is smaller than z otherwise, if inventory is less than or equal to z aim to use otherwise, if inventory is smaller than z  use , or try to use otherwise

RLang: Policy : \n \t if c > x : \n \t \t Execute run \n elif c < x : \n \t \t Execute run \n elif x : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: it would be good to try to run if c is greater than x otherwise, if c is smaller than x  run otherwise, if x attempt to run , or aim to run as a last resort

RLang: Policy collect_wood := \n \t if c < y : \n \t \t Execute find \n elif c == y : \n \t \t Execute find \n elif c != y : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: collect_wood means that it would be good to try to find if c is smaller than y otherwise, if c is exactly the same as y aim to find otherwise, if c is not the same as y aim to find , or aim to find otherwise

RLang: Policy : \n \t if inventory != y : \n \t \t Execute build \n elif inventory < y : \n \t \t Execute build \n elif inventory < y : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: it is a good idea if you try to build if inventory is not equal to y otherwise, if inventory is smaller than y aim to build otherwise, if inventory is less than y  build , or aim to build if no other options are possible

RLang: Policy : \n \t if position : \n \t \t Execute build \n elif position <= x : \n \t \t Execute build \n elif position >= x : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: it would be good to aim to build if position otherwise, if position is less than or equal to x  build otherwise, if position is greater than or the same as x  build , or aim to build if no other options are possible

RLang: Policy : \n \t if b : \n \t \t Execute find \n elif x : \n \t \t Execute find \n elif b > x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: you can try attempt to find if b otherwise, if x attempt to find otherwise, if b is larger than x  find , or aim to find if not

RLang: Policy : \n \t if a == z : \n \t \t Execute run \n elif a <= z : \n \t \t Execute run \n elif a <= z : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: it is a good idea for you aim to run if a is exactly the same as z otherwise, if a is less than or the same as z attempt to run otherwise, if a is smaller than or the same as z aim to run , or  run if not

RLang: Policy collect_wood := \n \t if inventory > y : \n \t \t Execute use \n elif inventory != y : \n \t \t Execute use \n elif inventory >= y : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: collect_wood means that it would be good to aim to use if inventory is greater than y otherwise, if inventory is not equal to y  use otherwise, if inventory is larger than or equal to y try to use , or  use if no other options are possible

RLang: Policy cross_the_street := \n \t if a : \n \t \t Execute search \n elif y : \n \t \t Execute search \n elif a < y : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: cross_the_street means that it would be good to try to search if a otherwise, if y  search otherwise, if a is smaller than y attempt to search , or attempt to search as a last resort

RLang: Policy : \n \t if inventory != z : \n \t \t Execute build \n elif inventory != z : \n \t \t Execute build \n elif inventory >= z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: it would be advantageous to attempt to build if inventory is not equal to z otherwise, if inventory is not the same as z  build otherwise, if inventory is larger than or the same as z try to build , or aim to build otherwise

RLang: Policy build_bridge := \n \t if c : \n \t \t Execute find \n elif c == y : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: build_bridge is an approach where you  find if c otherwise, if c is exactly the same as y attempt to find , or aim to find if no other options are possible

RLang: Policy collect_wood := \n \t if a : \n \t \t Execute run \n elif a <= x : \n \t \t Execute run \n elif a != x : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: collect_wood is an approach where it would be good to  run if a otherwise, if a is less than or the same as x  run otherwise, if a is not the same as x attempt to run , or  run otherwise

RLang: Policy : \n \t if inventory >= z : \n \t \t Execute build \n elif inventory == z : \n \t \t Execute build \n elif inventory == z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: it would be advantageous to aim to build if inventory is greater than or equal to z otherwise, if inventory is exactly the same as z aim to build otherwise, if inventory is equal to z aim to build , or attempt to build as a last resort

RLang: Policy : \n \t if c : \n \t \t Execute find \n elif c >= y : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: you can try attempt to find if c otherwise, if c is larger than or the same as y aim to find , or  find if not

RLang: Policy : \n \t if b <= z : \n \t \t Execute build \n elif b >= z : \n \t \t Execute build \n elif b <= z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: it would be good to attempt to build if b is less than or the same as z otherwise, if b is larger than or equal to z attempt to build otherwise, if b is less than or equal to z try to build , or aim to build if no other options are possible

RLang: Policy : \n \t if position <= x : \n \t \t Execute walk \n elif x : \n \t \t Execute walk \n elif position == x : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: it would be good to  walk if position is smaller than or the same as x otherwise, if x aim to walk otherwise, if position is exactly the same as x  walk , or  walk as a last resort

RLang: Policy : \n \t if a > x : \n \t \t Execute run \n elif x : \n \t \t Execute run \n elif a > x : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: you should attempt to run if a is greater than x otherwise, if x  run otherwise, if a is larger than x  run , or attempt to run otherwise

RLang: Policy cross_the_street := \n \t if a == x : \n \t \t Execute use \n
English: cross_the_street is an approach where it would be good to  use if a is equal to x

RLang: Policy : \n \t if b < y : \n \t \t Execute walk \n elif b <= y : \n \t \t Execute walk \n elif b > y : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: you should aim to walk if b is less than y otherwise, if b is less than or equal to y  walk otherwise, if b is greater than y aim to walk , or try to walk otherwise

RLang: Policy : \n \t if a == y : \n \t \t Execute jump \n elif a == y : \n \t \t Execute jump \n elif a < y : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: it is a good idea for you try to jump if a is equal to y otherwise, if a is exactly the same as y attempt to jump otherwise, if a is smaller than y attempt to jump , or try to jump as a last resort

RLang: Policy collect_wood := \n \t if c >= z : \n \t \t Execute jump \n elif z : \n \t \t Execute jump \n elif z : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: collect_wood is a strategy where you try to jump if c is greater than or the same as z otherwise, if z try to jump otherwise, if z  jump , or attempt to jump if no other options are possible

RLang: Policy cross_the_street := \n \t if a > x : \n \t \t Execute build \n elif x : \n \t \t Execute build \n elif a < x : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: cross_the_street entails that you aim to build if a is greater than x otherwise, if x aim to build otherwise, if a is less than x  build , or attempt to build if no other options are possible

RLang: Policy : \n \t if c >= x : \n \t \t Execute use \n elif c != x : \n \t \t Execute use \n elif c <= x : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: it would be advantageous to  use if c is greater than or the same as x otherwise, if c is not equal to x aim to use otherwise, if c is less than or the same as x aim to use , or try to use if no other options are possible

RLang: Policy build_bridge := \n \t if inventory <= x : \n \t \t Execute build \n elif inventory <= x : \n \t \t Execute build \n elif inventory >= x : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: build_bridge is a good strategy where you should aim to build if inventory is less than or the same as x otherwise, if inventory is less than or the same as x aim to build otherwise, if inventory is greater than or equal to x aim to build , or aim to build if not

RLang: Policy : \n \t if b <= y : \n \t \t Execute build \n elif b <= y : \n \t \t Execute build \n elif b > y : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: you can attempt to build if b is smaller than or the same as y otherwise, if b is less than or equal to y attempt to build otherwise, if b is greater than y aim to build , or aim to build as a last resort

RLang: Policy do_the_thing := \n \t if inventory : \n \t \t Execute build \n elif x : \n \t \t Execute build \n elif inventory > x : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: do_the_thing is a good strategy where you should attempt to build if inventory otherwise, if x attempt to build otherwise, if inventory is larger than x  build , or  build otherwise

RLang: Policy cross_the_street := \n \t if c != x : \n \t \t Execute search \n elif c >= x : \n \t \t Execute search \n elif c != x : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: cross_the_street is an approach where you try to search if c is not the same as x otherwise, if c is larger than or the same as x try to search otherwise, if c is not equal to x attempt to search , or aim to search if not

RLang: Policy : \n \t if position != x : \n \t \t Execute use \n elif position <= x : \n \t \t Execute use \n elif position <= x : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: it is a good idea for you attempt to use if position is not the same as x otherwise, if position is smaller than or equal to x aim to use otherwise, if position is less than or the same as x try to use , or try to use as a last resort

RLang: Policy collect_wood := \n \t if a < y : \n \t \t Execute search \n elif a > y : \n \t \t Execute search \n elif y : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: collect_wood suggests that it would be advantageous to attempt to search if a is less than y otherwise, if a is larger than y aim to search otherwise, if y attempt to search , or attempt to search otherwise

RLang: Policy build_bridge := \n \t if c < x : \n \t \t Execute walk \n elif c >= x : \n \t \t Execute walk \n elif c > x : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: build_bridge is an approach where it would be good to attempt to walk if c is smaller than x otherwise, if c is greater than or equal to x try to walk otherwise, if c is larger than x aim to walk , or aim to walk if not

RLang: Policy build_bridge := \n \t if a == z : \n \t \t Execute build \n elif a <= z : \n \t \t Execute build \n elif a >= z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: build_bridge is an approach where it would be good to try to build if a is equal to z otherwise, if a is smaller than or equal to z attempt to build otherwise, if a is greater than or the same as z try to build , or  build as a last resort

RLang: Policy : \n \t if position != y : \n \t \t Execute use \n elif position != y : \n \t \t Execute use \n elif y : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: you should  use if position is not equal to y otherwise, if position is not equal to y aim to use otherwise, if y  use , or attempt to use if no other options are possible

RLang: Policy : \n \t if inventory : \n \t \t Execute find \n elif inventory == z : \n \t \t Execute find \n elif inventory < z : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: it would be good to aim to find if inventory otherwise, if inventory is exactly the same as z  find otherwise, if inventory is less than z  find , or  find as a last resort

RLang: Policy do_something := \n \t if c : \n \t \t Execute build \n elif c > z : \n \t \t Execute build \n elif c >= z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: do_something means that it would be good to aim to build if c otherwise, if c is larger than z  build otherwise, if c is greater than or the same as z aim to build , or  build if not

RLang: Policy do_something := \n \t if inventory : \n \t \t Execute find \n elif inventory < y : \n \t \t Execute find \n elif inventory != y : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: do_something is a strategy where you attempt to find if inventory otherwise, if inventory is less than y try to find otherwise, if inventory is not the same as y try to find , or  find otherwise

RLang: Policy do_something := \n \t if c <= z : \n \t \t Execute run \n elif c <= z : \n \t \t Execute run \n elif z : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: do_something is a tactic where it is advantageous to  run if c is less than or the same as z otherwise, if c is smaller than or equal to z  run otherwise, if z  run , or  run if not

RLang: Policy : \n \t if b == y : \n \t \t Execute jump \n elif b < y : \n \t \t Execute jump \n elif b > y : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: it is a good idea for you  jump if b is exactly the same as y otherwise, if b is less than y  jump otherwise, if b is greater than y attempt to jump , or try to jump if no other options are possible

RLang: Policy : \n \t if position == y : \n \t \t Execute use \n elif y : \n \t \t Execute use \n elif position <= y : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: you should attempt to use if position is exactly the same as y otherwise, if y  use otherwise, if position is smaller than or the same as y try to use , or attempt to use if not

RLang: Policy build_bridge := \n \t if b == z : \n \t \t Execute jump \n elif z : \n \t \t Execute jump \n elif b <= z : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: build_bridge entails that you attempt to jump if b is exactly the same as z otherwise, if z try to jump otherwise, if b is less than or the same as z try to jump , or attempt to jump if no other options are possible

RLang: Policy build_bridge := \n \t if position <= x : \n \t \t Execute find \n elif position != x : \n \t \t Execute find \n elif position == x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: build_bridge is an approach where it would be good to aim to find if position is smaller than or equal to x otherwise, if position is not equal to x attempt to find otherwise, if position is exactly the same as x try to find , or aim to find otherwise

RLang: Policy : \n \t if c != x : \n \t \t Execute find \n elif c < x : \n \t \t Execute find \n elif c != x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: you can try  find if c is not equal to x otherwise, if c is smaller than x aim to find otherwise, if c is not equal to x attempt to find , or  find as a last resort

RLang: Policy do_something := \n \t if inventory <= z : \n \t \t Execute walk \n elif z : \n \t \t Execute walk \n elif inventory > z : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: do_something states that you should aim to walk if inventory is smaller than or equal to z otherwise, if z aim to walk otherwise, if inventory is larger than z  walk , or try to walk otherwise

RLang: Policy : \n \t if c <= z : \n \t \t Execute use \n elif c >= z : \n \t \t Execute use \n elif c == z : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: it is a good idea for you aim to use if c is less than or the same as z otherwise, if c is larger than or equal to z try to use otherwise, if c is exactly the same as z attempt to use , or try to use if not

RLang: Policy do_the_thing := \n \t if a == x : \n \t \t Execute jump \n elif a < x : \n \t \t Execute jump \n elif a == x : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: do_the_thing is a strategy where you  jump if a is exactly the same as x otherwise, if a is less than x aim to jump otherwise, if a is equal to x  jump , or  jump as a last resort

RLang: Policy : \n \t if b != x : \n \t \t Execute find \n elif b != x : \n \t \t Execute find \n elif b <= x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: it is a good idea if you  find if b is not equal to x otherwise, if b is not the same as x attempt to find otherwise, if b is less than or equal to x aim to find , or  find as a last resort

RLang: Policy collect_wood := \n \t if c >= z : \n \t \t Execute walk \n elif z : \n \t \t Execute walk \n elif z : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: collect_wood means that it would be good to attempt to walk if c is greater than or the same as z otherwise, if z try to walk otherwise, if z aim to walk , or aim to walk if no other options are possible

RLang: Policy : \n \t if c != x : \n \t \t Execute walk \n elif c == x : \n \t \t Execute walk \n elif c > x : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: you can try  walk if c is not equal to x otherwise, if c is equal to x aim to walk otherwise, if c is larger than x  walk , or  walk if no other options are possible

RLang: Policy cross_the_street := \n \t if b < x : \n \t \t Execute use \n elif b == x : \n \t \t Execute use \n elif b == x : \n \t \t Execute use \n else : \n \t \t Execute use \n
English: cross_the_street is a strategy where you  use if b is less than x otherwise, if b is exactly the same as x  use otherwise, if b is equal to x aim to use , or aim to use as a last resort

RLang: Policy : \n \t if position < z : \n \t \t Execute walk \n elif position > z : \n \t \t Execute walk \n elif position != z : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: it is a good idea if you  walk if position is less than z otherwise, if position is larger than z  walk otherwise, if position is not the same as z  walk , or  walk if no other options are possible

RLang: Policy : \n \t if a != y : \n \t \t Execute build \n elif a != y : \n \t \t Execute build \n elif a > y : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: you should attempt to build if a is not equal to y otherwise, if a is not the same as y attempt to build otherwise, if a is greater than y attempt to build , or aim to build otherwise

RLang: Policy : \n \t if b < z : \n \t \t Execute run \n elif b == z : \n \t \t Execute run \n elif b >= z : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: you should aim to run if b is less than z otherwise, if b is exactly the same as z try to run otherwise, if b is larger than or equal to z try to run , or aim to run otherwise

RLang: Policy do_something := \n \t if inventory <= x : \n \t \t Execute search \n elif x : \n \t \t Execute search \n elif inventory == x : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: do_something is a good strategy where you should  search if inventory is smaller than or equal to x otherwise, if x try to search otherwise, if inventory is equal to x aim to search , or attempt to search as a last resort

RLang: Policy : \n \t if b : \n \t \t Execute search \n elif b == x : \n \t \t Execute search \n elif x : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: you should attempt to search if b otherwise, if b is equal to x attempt to search otherwise, if x attempt to search , or aim to search as a last resort

RLang: Policy do_something := \n \t if position : \n \t \t Execute walk \n elif position <= x : \n \t \t Execute walk \n elif x : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: do_something entails that you  walk if position otherwise, if position is less than or equal to x aim to walk otherwise, if x  walk , or aim to walk as a last resort

RLang: Policy : \n \t if inventory < y : \n \t \t Execute jump \n elif inventory < y : \n \t \t Execute jump \n elif inventory == y : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: you can try to jump if inventory is smaller than y otherwise, if inventory is less than y  jump otherwise, if inventory is equal to y attempt to jump , or  jump if no other options are possible

RLang: Policy : \n \t if position <= z : \n \t \t Execute jump \n
English: it is a good idea if you attempt to jump if position is smaller than or the same as z

RLang: Policy do_something := \n \t if inventory <= x : \n \t \t Execute jump \n elif inventory > x : \n \t \t Execute jump \n elif inventory > x : \n \t \t Execute jump \n else : \n \t \t Execute jump \n
English: do_something means that it would be good to try to jump if inventory is smaller than or the same as x otherwise, if inventory is larger than x  jump otherwise, if inventory is greater than x aim to jump , or attempt to jump if not

RLang: Policy : \n \t if c < x : \n \t \t Execute search \n elif x : \n \t \t Execute search \n elif x : \n \t \t Execute search \n else : \n \t \t Execute search \n
English: you can try to search if c is smaller than x otherwise, if x try to search otherwise, if x attempt to search , or aim to search as a last resort

RLang: Policy do_the_thing := \n \t if a > z : \n \t \t Execute run \n elif z : \n \t \t Execute run \n elif a == z : \n \t \t Execute run \n else : \n \t \t Execute run \n
English: do_the_thing is a tactic where it is advantageous to aim to run if a is greater than z otherwise, if z try to run otherwise, if a is exactly the same as z aim to run , or attempt to run if no other options are possible

RLang: Policy build_bridge := \n \t if b <= y : \n \t \t Execute build \n elif y : \n \t \t Execute build \n elif b < y : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: build_bridge states that you should  build if b is less than or equal to y otherwise, if y aim to build otherwise, if b is less than y  build , or try to build if not

RLang: Policy do_something := \n \t if a != y : \n \t \t Execute walk \n elif a <= y : \n \t \t Execute walk \n elif a == y : \n \t \t Execute walk \n else : \n \t \t Execute walk \n
English: do_something is an approach where it would be good to  walk if a is not the same as y otherwise, if a is less than or the same as y aim to walk otherwise, if a is equal to y try to walk , or attempt to walk otherwise

RLang: Policy cross_the_street := \n \t if a != z : \n \t \t Execute find \n elif a >= z : \n \t \t Execute find \n elif z : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: cross_the_street is a tactic where it is advantageous to try to find if a is not the same as z otherwise, if a is greater than or the same as z try to find otherwise, if z try to find , or aim to find if no other options are possible

RLang: Policy collect_wood := \n \t if a != z : \n \t \t Execute build \n elif a <= z : \n \t \t Execute build \n elif a > z : \n \t \t Execute build \n else : \n \t \t Execute build \n
English: collect_wood is a strategy where you  build if a is not equal to z otherwise, if a is less than or the same as z aim to build otherwise, if a is greater than z  build , or try to build if no other options are possible

RLang: Policy do_the_thing := \n \t if c < x : \n \t \t Execute find \n elif x : \n \t \t Execute find \n else : \n \t \t Execute find \n
English: do_the_thing is a strategy where you  find if c is less than x otherwise, if x aim to find , or  find if not

