RLang: Option : \n \t init position <= y \n \t \t Policy : \n \t \t \t if position : \n \t Execute run \n \n \t until position <= y
English: in the case when position is smaller than or the same as y you can try attempt to run if position as soon as position is smaller than or the same as y

RLang: Option : \n \t init c <= x \n \t \t Policy : \n \t \t \t if c : \n \t Execute search \n \n \t until x
English: in the case when c is less than or equal to x it is a good idea if you aim to search if c as soon as x

RLang: Option : \n \t init a == x \n \t \t Policy : \n \t \t \t if a : \n \t Execute build \n \n \t until a > x
English: in the case when a is equal to x it would be good to  build if a until a is larger than x

RLang: Option : \n \t init b < y \n \t \t Policy : \n \t \t \t if b > y : \n \t Execute walk \n else : \n \t Execute walk \n \n \t until b < y
English: in the case when b is less than y it would be good to try to walk if b is greater than y , or try to walk if not once b is smaller than y

RLang: Option : \n \t init b >= x \n \t \t Policy : \n \t \t \t if b : \n \t Execute use \n \n \t until b <= x
English: in the case when b is greater than or equal to x it would be advantageous to attempt to use if b once b is smaller than or equal to x

RLang: Option : \n \t init a >= z \n \t \t Policy : \n \t \t \t if a == z : \n \t Execute run \n \n \t until a
English: if you see that a is larger than or equal to z it is a good idea for you try to run if a is equal to z when a

RLang: Option : \n \t init position <= y \n \t \t Policy : \n \t \t \t if position <= y : \n \t Execute jump \n \n \t until position == y
English: in a scenario where position is smaller than or the same as y it is a good idea for you attempt to jump if position is smaller than or equal to y once position is equal to y

RLang: Option : \n \t init b > x \n \t \t Policy : \n \t \t \t if b < x : \n \t Execute run \n \n \t until b != x
English: given that b is larger than x you can try to run if b is less than x as soon as b is not equal to x

RLang: Option : \n \t init b >= z \n \t \t Policy : \n \t \t \t if b : \n \t Execute find \n \n \t until b < z
English: in the case when b is greater than or the same as z it would be advantageous to try to find if b when b is less than z

RLang: Option : \n \t init c > x \n \t \t Policy : \n \t \t \t if c <= x : \n \t Execute use \n else : \n \t Execute use \n \n \t until c <= x
English: in a scenario where c is larger than x you can aim to use if c is smaller than or the same as x , or  use if not once c is less than or the same as x

RLang: Option : \n \t init inventory \n \t \t Policy : \n \t \t \t if inventory != z : \n \t Execute jump \n \n \t until inventory >= z
English: if you see that inventory it is a good idea if you aim to jump if inventory is not the same as z until inventory is larger than or equal to z

RLang: Option : \n \t init b < y \n \t \t Policy : \n \t \t \t if b <= y : \n \t Execute use \n \n \t until b > y
English: if you see that b is smaller than y it is a good idea if you  use if b is less than or equal to y when b is larger than y

RLang: Option : \n \t init b >= z \n \t \t Policy : \n \t \t \t if b >= z : \n \t Execute walk \n \n \t until b > z
English: if you see that b is greater than or equal to z it is a good idea for you attempt to walk if b is larger than or the same as z until b is greater than z

RLang: Option : \n \t init position != z \n \t \t Policy : \n \t \t \t if z : \n \t Execute search \n \n \t until position == z
English: in the case when position is not the same as z it is a good idea for you  search if z when position is equal to z

RLang: Option : \n \t init b < x \n \t \t Policy : \n \t \t \t if x : \n \t Execute walk \n else : \n \t Execute walk \n \n \t until x
English: if you see that b is less than x you should try to walk if x , or aim to walk otherwise as soon as x

RLang: Option : \n \t init inventory != x \n \t \t Policy : \n \t \t \t if x : \n \t Execute run \n \n \t until inventory != x
English: in the case when inventory is not the same as x you can try  run if x as soon as inventory is not the same as x

RLang: Option : \n \t init position != x \n \t \t Policy : \n \t \t \t Execute jump \n \n \t until position != x
English: if you see that position is not the same as x you can try aim to jump when position is not equal to x

RLang: Option : \n \t init inventory \n \t \t Policy : \n \t \t \t if inventory : \n \t Execute find \n else : \n \t Execute find \n \n \t until inventory <= x
English: in a scenario where inventory it would be good to aim to find if inventory , or aim to find if no other options are possible as soon as inventory is less than or the same as x

RLang: Option : \n \t init position < y \n \t \t Policy : \n \t \t \t if position != y : \n \t Execute jump \n else : \n \t Execute jump \n \n \t until position < y
English: in the case when position is less than y it would be advantageous to aim to jump if position is not equal to y , or try to jump as a last resort as soon as position is smaller than y

RLang: Option : \n \t init inventory >= y \n \t \t Policy : \n \t \t \t if inventory != y : \n \t Execute find \n else : \n \t Execute find \n \n \t until inventory != y
English: in the case when inventory is greater than or equal to y you can try aim to find if inventory is not equal to y , or  find otherwise once inventory is not the same as y

RLang: Option : \n \t init x \n \t \t Policy : \n \t \t \t if x : \n \t Execute find \n \n \t until inventory > x
English: given that x it would be advantageous to aim to find if x as soon as inventory is greater than x

RLang: Option : \n \t init c \n \t \t Policy : \n \t \t \t if c : \n \t Execute find \n \n \t until c == x
English: in a scenario where c you should aim to find if c when c is exactly the same as x

RLang: Option : \n \t init position != z \n \t \t Policy : \n \t \t \t if position : \n \t Execute run \n else : \n \t Execute run \n \n \t until position > z
English: in a scenario where position is not the same as z it would be good to  run if position , or  run if not when position is greater than z

RLang: Option : \n \t init b > z \n \t \t Policy : \n \t \t \t if b > z : \n \t Execute use \n \n \t until b
English: in the case when b is larger than z it is a good idea for you  use if b is greater than z until b

RLang: Option : \n \t init c != z \n \t \t Policy : \n \t \t \t if c : \n \t Execute jump \n \n \t until c == z
English: if you see that c is not the same as z you can  jump if c when c is exactly the same as z

RLang: Option : \n \t init x \n \t \t Policy : \n \t \t \t if b > x : \n \t Execute build \n else : \n \t Execute build \n \n \t until b > x
English: if you see that x it would be good to aim to build if b is greater than x , or aim to build if no other options are possible once b is greater than x

RLang: Option : \n \t init c == x \n \t \t Policy : \n \t \t \t if c <= x : \n \t Execute run \n else : \n \t Execute run \n \n \t until c == x
English: in the case when c is equal to x it would be advantageous to aim to run if c is less than or the same as x , or  run if not when c is equal to x

RLang: Option : \n \t init x \n \t \t Policy : \n \t \t \t if a > x : \n \t Execute walk \n \n \t until a < x
English: in a scenario where x it would be advantageous to attempt to walk if a is larger than x when a is smaller than x

RLang: Option : \n \t init position > y \n \t \t Policy : \n \t \t \t if y : \n \t Execute search \n \n \t until position >= y
English: in a scenario where position is larger than y it would be advantageous to aim to search if y when position is larger than or equal to y

RLang: Option : \n \t init position >= x \n \t \t Policy : \n \t \t \t Execute jump \n \n \t until position > x
English: in the case when position is greater than or equal to x you can attempt to jump as soon as position is greater than x

RLang: Option : \n \t init a >= y \n \t \t Policy : \n \t \t \t if a : \n \t Execute use \n else : \n \t Execute use \n \n \t until y
English: if you see that a is larger than or the same as y it would be good to  use if a , or attempt to use as a last resort once y

RLang: Option : \n \t init position != x \n \t \t Policy : \n \t \t \t if position : \n \t Execute build \n \n \t until position < x
English: in the case when position is not the same as x it would be good to attempt to build if position once position is smaller than x

RLang: Option : \n \t init b > x \n \t \t Policy : \n \t \t \t if b > x : \n \t Execute build \n else : \n \t Execute build \n \n \t until b <= x
English: if you see that b is greater than x you should  build if b is larger than x , or  build as a last resort until b is smaller than or equal to x

RLang: Option : \n \t init c <= x \n \t \t Policy : \n \t \t \t if c == x : \n \t Execute walk \n else : \n \t Execute walk \n \n \t until c != x
English: given that c is smaller than or the same as x it would be good to aim to walk if c is exactly the same as x , or aim to walk if no other options are possible when c is not the same as x

RLang: Option : \n \t init position > x \n \t \t Policy : \n \t \t \t if position >= x : \n \t Execute jump \n \n \t until position < x
English: given that position is greater than x it would be advantageous to attempt to jump if position is greater than or the same as x once position is less than x

RLang: Option : \n \t init c \n \t \t Policy : \n \t \t \t if x : \n \t Execute run \n \n \t until c > x
English: given that c it would be advantageous to aim to run if x when c is larger than x

RLang: Option : \n \t init inventory \n \t \t Policy : \n \t \t \t if inventory <= x : \n \t Execute search \n else : \n \t Execute search \n \n \t until inventory <= x
English: in a scenario where inventory you can attempt to search if inventory is smaller than or equal to x , or  search as a last resort when inventory is less than or the same as x

RLang: Option : \n \t init b < x \n \t \t Policy : \n \t \t \t if b != x : \n \t Execute run \n \n \t until b == x
English: in a scenario where b is less than x it is a good idea for you  run if b is not the same as x once b is equal to x

RLang: Option : \n \t init position >= x \n \t \t Policy : \n \t \t \t if position : \n \t Execute run \n else : \n \t Execute run \n \n \t until position == x
English: in the case when position is larger than or equal to x you should aim to run if position , or try to run if no other options are possible once position is equal to x

RLang: Option : \n \t init inventory >= z \n \t \t Policy : \n \t \t \t if inventory : \n \t Execute walk \n \n \t until inventory < z
English: in the case when inventory is greater than or the same as z it is a good idea for you  walk if inventory once inventory is smaller than z

RLang: Option : \n \t init b <= x \n \t \t Policy : \n \t \t \t if b < x : \n \t Execute run \n else : \n \t Execute run \n \n \t until b < x
English: in the case when b is smaller than or the same as x you can try try to run if b is smaller than x , or attempt to run otherwise until b is less than x

RLang: Option : \n \t init c >= x \n \t \t Policy : \n \t \t \t if c : \n \t Execute search \n else : \n \t Execute search \n \n \t until c != x
English: in a scenario where c is larger than or equal to x you can try aim to search if c , or try to search if not when c is not the same as x

RLang: Option : \n \t init b < y \n \t \t Policy : \n \t \t \t if b > y : \n \t Execute run \n else : \n \t Execute run \n \n \t until b >= y
English: in the case when b is smaller than y it is a good idea for you attempt to run if b is larger than y , or  run if not as soon as b is larger than or equal to y

RLang: Option : \n \t init position == z \n \t \t Policy : \n \t \t \t if position != z : \n \t Execute find \n else : \n \t Execute find \n \n \t until position != z
English: in a scenario where position is equal to z you can try  find if position is not equal to z , or aim to find as a last resort when position is not the same as z

RLang: Option : \n \t init position >= z \n \t \t Policy : \n \t \t \t if position >= z : \n \t Execute jump \n else : \n \t Execute jump \n \n \t until position != z
English: in the case when position is larger than or equal to z it would be advantageous to attempt to jump if position is larger than or the same as z , or  jump as a last resort when position is not equal to z

RLang: Option : \n \t init b == z \n \t \t Policy : \n \t \t \t if b == z : \n \t Execute jump \n \n \t until b > z
English: in the case when b is exactly the same as z you should attempt to jump if b is exactly the same as z when b is greater than z

RLang: Option : \n \t init inventory == x \n \t \t Policy : \n \t \t \t if x : \n \t Execute find \n else : \n \t Execute find \n \n \t until inventory
English: in the case when inventory is equal to x it is a good idea if you  find if x , or attempt to find if no other options are possible when inventory

RLang: Option : \n \t init z \n \t \t Policy : \n \t \t \t if c == z : \n \t Execute jump \n else : \n \t Execute jump \n \n \t until z
English: in the case when z it would be good to try to jump if c is exactly the same as z , or try to jump otherwise when z

RLang: Option : \n \t init a <= x \n \t \t Policy : \n \t \t \t if a < x : \n \t Execute use \n \n \t until a <= x
English: in the case when a is less than or equal to x it is a good idea for you try to use if a is less than x once a is smaller than or equal to x

RLang: Option : \n \t init x \n \t \t Policy : \n \t \t \t if a : \n \t Execute walk \n else : \n \t Execute walk \n \n \t until a < x
English: in a scenario where x it would be advantageous to aim to walk if a , or try to walk if not until a is less than x

RLang: Option : \n \t init z \n \t \t Policy : \n \t \t \t if b : \n \t Execute walk \n \n \t until b >= z
English: in the case when z you can try to walk if b until b is larger than or the same as z

RLang: Option : \n \t init position \n \t \t Policy : \n \t \t \t if position == y : \n \t Execute build \n else : \n \t Execute build \n \n \t until y
English: if you see that position it is a good idea for you attempt to build if position is equal to y , or attempt to build as a last resort once y

RLang: Option : \n \t init inventory == x \n \t \t Policy : \n \t \t \t Execute use \n \n \t until inventory < x
English: given that inventory is equal to x you can aim to use once inventory is less than x

RLang: Option : \n \t init inventory \n \t \t Policy : \n \t \t \t if x : \n \t Execute use \n \n \t until inventory >= x
English: in the case when inventory you should try to use if x until inventory is larger than or the same as x

RLang: Option : \n \t init b >= x \n \t \t Policy : \n \t \t \t if b < x : \n \t Execute walk \n \n \t until b >= x
English: given that b is greater than or the same as x you should attempt to walk if b is less than x until b is larger than or the same as x

RLang: Option : \n \t init inventory > z \n \t \t Policy : \n \t \t \t if inventory : \n \t Execute build \n else : \n \t Execute build \n \n \t until inventory != z
English: in the case when inventory is greater than z you can aim to build if inventory , or try to build as a last resort once inventory is not equal to z

RLang: Option : \n \t init b < y \n \t \t Policy : \n \t \t \t if b : \n \t Execute search \n else : \n \t Execute search \n \n \t until b
English: if you see that b is smaller than y you should  search if b , or  search if no other options are possible once b

RLang: Option : \n \t init z \n \t \t Policy : \n \t \t \t if inventory > z : \n \t Execute find \n else : \n \t Execute find \n \n \t until inventory <= z
English: in the case when z you can aim to find if inventory is greater than z , or aim to find otherwise when inventory is less than or equal to z

RLang: Option : \n \t init position > x \n \t \t Policy : \n \t \t \t if position : \n \t Execute find \n \n \t until position
English: in the case when position is larger than x you can try aim to find if position when position

RLang: Option : \n \t init x \n \t \t Policy : \n \t \t \t if x : \n \t Execute search \n \n \t until b == x
English: in the case when x you should aim to search if x once b is exactly the same as x

RLang: Option : \n \t init position == z \n \t \t Policy : \n \t \t \t if position != z : \n \t Execute jump \n else : \n \t Execute jump \n \n \t until position > z
English: in a scenario where position is exactly the same as z it is a good idea for you aim to jump if position is not the same as z , or aim to jump if not as soon as position is greater than z

RLang: Option : \n \t init position < y \n \t \t Policy : \n \t \t \t Execute find \n \n \t until position >= y
English: given that position is smaller than y it would be advantageous to attempt to find when position is larger than or the same as y

RLang: Option : \n \t init a \n \t \t Policy : \n \t \t \t Execute use \n \n \t until a
English: given that a you should  use until a

RLang: Option : \n \t init position < y \n \t \t Policy : \n \t \t \t if position >= y : \n \t Execute build \n \n \t until position != y
English: in a scenario where position is smaller than y you should try to build if position is greater than or the same as y until position is not the same as y

RLang: Option : \n \t init a < y \n \t \t Policy : \n \t \t \t if a : \n \t Execute build \n else : \n \t Execute build \n \n \t until a != y
English: given that a is smaller than y it is a good idea if you attempt to build if a , or attempt to build if no other options are possible until a is not the same as y

RLang: Option : \n \t init a != z \n \t \t Policy : \n \t \t \t if z : \n \t Execute walk \n \n \t until a
English: if you see that a is not equal to z it is a good idea if you aim to walk if z as soon as a

RLang: Option : \n \t init a >= y \n \t \t Policy : \n \t \t \t if a > y : \n \t Execute walk \n else : \n \t Execute walk \n \n \t until a
English: in the case when a is greater than or the same as y you can try to walk if a is larger than y , or attempt to walk if not as soon as a

RLang: Option : \n \t init inventory <= y \n \t \t Policy : \n \t \t \t if inventory > y : \n \t Execute build \n else : \n \t Execute build \n \n \t until inventory <= y
English: if you see that inventory is less than or the same as y you should  build if inventory is greater than y , or aim to build if not once inventory is less than or equal to y

RLang: Option : \n \t init a == y \n \t \t Policy : \n \t \t \t if y : \n \t Execute find \n else : \n \t Execute find \n \n \t until a < y
English: given that a is equal to y it is a good idea for you try to find if y , or aim to find if not as soon as a is less than y

RLang: Option : \n \t init c == x \n \t \t Policy : \n \t \t \t if c >= x : \n \t Execute jump \n else : \n \t Execute jump \n \n \t until c >= x
English: if you see that c is exactly the same as x it is a good idea if you try to jump if c is larger than or equal to x , or attempt to jump if no other options are possible as soon as c is greater than or equal to x

RLang: Option : \n \t init position > z \n \t \t Policy : \n \t \t \t if position : \n \t Execute find \n \n \t until position != z
English: if you see that position is greater than z you should  find if position until position is not the same as z

RLang: Option : \n \t init a >= z \n \t \t Policy : \n \t \t \t if a : \n \t Execute find \n \n \t until a == z
English: if you see that a is larger than or equal to z you can aim to find if a as soon as a is equal to z

RLang: Option : \n \t init c >= z \n \t \t Policy : \n \t \t \t if c != z : \n \t Execute run \n \n \t until c >= z
English: in a scenario where c is larger than or equal to z you should attempt to run if c is not equal to z when c is larger than or the same as z

RLang: Option : \n \t init a != y \n \t \t Policy : \n \t \t \t if a == y : \n \t Execute use \n \n \t until a >= y
English: if you see that a is not equal to y you should  use if a is equal to y once a is larger than or the same as y

RLang: Option : \n \t init a > y \n \t \t Policy : \n \t \t \t if a != y : \n \t Execute use \n \n \t until a >= y
English: in the case when a is larger than y it is a good idea for you aim to use if a is not equal to y once a is greater than or equal to y

RLang: Option : \n \t init position >= x \n \t \t Policy : \n \t \t \t if position >= x : \n \t Execute find \n else : \n \t Execute find \n \n \t until position
English: in the case when position is greater than or the same as x you can try to find if position is greater than or equal to x , or  find otherwise when position

RLang: Option : \n \t init position > x \n \t \t Policy : \n \t \t \t if position : \n \t Execute build \n \n \t until position <= x
English: in the case when position is larger than x it would be advantageous to try to build if position until position is less than or equal to x

RLang: Option : \n \t init x \n \t \t Policy : \n \t \t \t if x : \n \t Execute use \n \n \t until b
English: in the case when x it would be good to  use if x when b

RLang: Option : \n \t init b != x \n \t \t Policy : \n \t \t \t if b <= x : \n \t Execute walk \n \n \t until b <= x
English: given that b is not equal to x you should aim to walk if b is smaller than or the same as x once b is less than or equal to x

RLang: Option : \n \t init inventory >= y \n \t \t Policy : \n \t \t \t if inventory <= y : \n \t Execute jump \n else : \n \t Execute jump \n \n \t until inventory
English: in the case when inventory is greater than or equal to y you should try to jump if inventory is smaller than or equal to y , or  jump otherwise when inventory

RLang: Option : \n \t init a > z \n \t \t Policy : \n \t \t \t if a : \n \t Execute jump \n else : \n \t Execute jump \n \n \t until a != z
English: in a scenario where a is greater than z it is a good idea for you  jump if a , or aim to jump if no other options are possible when a is not equal to z

RLang: Option : \n \t init inventory >= x \n \t \t Policy : \n \t \t \t if inventory > x : \n \t Execute walk \n else : \n \t Execute walk \n \n \t until inventory == x
English: in a scenario where inventory is larger than or the same as x it would be advantageous to aim to walk if inventory is larger than x , or try to walk as a last resort once inventory is exactly the same as x

RLang: Option : \n \t init c < x \n \t \t Policy : \n \t \t \t if c == x : \n \t Execute build \n \n \t until c >= x
English: given that c is smaller than x you should try to build if c is equal to x once c is greater than or equal to x

RLang: Option : \n \t init c \n \t \t Policy : \n \t \t \t if c : \n \t Execute jump \n \n \t until c < x
English: if you see that c you can try try to jump if c as soon as c is smaller than x

RLang: Option : \n \t init inventory >= x \n \t \t Policy : \n \t \t \t if inventory <= x : \n \t Execute run \n else : \n \t Execute run \n \n \t until inventory
English: in a scenario where inventory is larger than or equal to x you can  run if inventory is smaller than or the same as x , or aim to run if no other options are possible when inventory

RLang: Option : \n \t init c \n \t \t Policy : \n \t \t \t if c < y : \n \t Execute walk \n \n \t until c >= y
English: given that c you can try to walk if c is smaller than y once c is larger than or equal to y

RLang: Option : \n \t init c > y \n \t \t Policy : \n \t \t \t if c : \n \t Execute run \n \n \t until c != y
English: given that c is larger than y it would be good to  run if c as soon as c is not equal to y

RLang: Option : \n \t init c <= x \n \t \t Policy : \n \t \t \t if c < x : \n \t Execute find \n else : \n \t Execute find \n \n \t until c
English: if you see that c is less than or the same as x it would be advantageous to attempt to find if c is less than x , or  find as a last resort once c

RLang: Option : \n \t init c == y \n \t \t Policy : \n \t \t \t if y : \n \t Execute find \n else : \n \t Execute find \n \n \t until c > y
English: in a scenario where c is exactly the same as y it is a good idea if you aim to find if y , or  find if no other options are possible when c is larger than y

RLang: Option : \n \t init a \n \t \t Policy : \n \t \t \t if a <= z : \n \t Execute use \n \n \t until a
English: given that a it would be advantageous to aim to use if a is less than or the same as z as soon as a

RLang: Option : \n \t init a <= y \n \t \t Policy : \n \t \t \t if a : \n \t Execute find \n \n \t until a <= y
English: in the case when a is smaller than or the same as y it is a good idea for you attempt to find if a once a is smaller than or equal to y

RLang: Option : \n \t init c > z \n \t \t Policy : \n \t \t \t if c >= z : \n \t Execute jump \n \n \t until c <= z
English: in the case when c is larger than z it is a good idea for you aim to jump if c is larger than or equal to z as soon as c is less than or equal to z

RLang: Option : \n \t init c \n \t \t Policy : \n \t \t \t if c : \n \t Execute build \n \n \t until y
English: in a scenario where c it is a good idea for you  build if c as soon as y

RLang: Option : \n \t init c < x \n \t \t Policy : \n \t \t \t if c : \n \t Execute build \n else : \n \t Execute build \n \n \t until c <= x
English: in the case when c is less than x it is a good idea if you try to build if c , or attempt to build if not as soon as c is less than or equal to x

RLang: Option : \n \t init a > y \n \t \t Policy : \n \t \t \t if a : \n \t Execute jump \n \n \t until a > y
English: if you see that a is greater than y it would be good to aim to jump if a until a is greater than y

RLang: Option : \n \t init c != x \n \t \t Policy : \n \t \t \t if c : \n \t Execute build \n else : \n \t Execute build \n \n \t until x
English: in a scenario where c is not equal to x you should try to build if c , or  build if not until x

RLang: Option : \n \t init a < y \n \t \t Policy : \n \t \t \t Execute find \n \n \t until a < y
English: if you see that a is smaller than y you can try try to find once a is less than y

RLang: Option : \n \t init a != y \n \t \t Policy : \n \t \t \t if y : \n \t Execute build \n else : \n \t Execute build \n \n \t until a >= y
English: in the case when a is not the same as y you can try try to build if y , or aim to build if not until a is greater than or equal to y

RLang: Option : \n \t init a == z \n \t \t Policy : \n \t \t \t if a >= z : \n \t Execute build \n \n \t until a == z
English: given that a is exactly the same as z it would be advantageous to try to build if a is larger than or equal to z until a is equal to z

RLang: Option : \n \t init b \n \t \t Policy : \n \t \t \t if y : \n \t Execute search \n \n \t until b
English: if you see that b you can try try to search if y when b

