Gemini 4 Argon, seed 1

harvest()
harvest()
harvest()
harvest()
harvest()

while True:
	harvest()

while True:
	if can_harvest():
		harvest()
	move(North)

while True:
	if can_harvest():
		harvest()
		plant(Entities.Bush)
	move(North)
	if can_harvest():
		harvest()
		plant(Entities.Bush)
	move(North)
	if can_harvest():
		harvest()
	move(North)

while True:
	for i in range(get_world_size()):
		if can_harvest():
			harvest()
		if get_pos_x() == 0 and get_pos_y() < 2:
			if get_ground_type() == Grounds.Soil:
				till()
		elif get_pos_x() == 2 and (get_world_size() > 3 or get_pos_y() < 2):
			if get_ground_type() != Grounds.Soil:
				till()
			if num_items(Items.Wood) > 5 and num_items(Items.Hay) > 5:
				plant(Entities.Carrot)
			else:
				plant(Entities.Bush)
		else:
			plant(Entities.Bush)
		move(North)
	move(East)

while True:
	ws = get_world_size()
	for i in range(ws):
		if can_harvest():
			harvest()
		x = get_pos_x()
		y = get_pos_y()
		even = (x + y) % 2 == 0
		if x == 0 or (ws >= 6 and x == 1):
			if get_ground_type() == Grounds.Soil:
				till()
			if even and num_items(Items.Hay) > 600 and num_items(Items.Wood) < 500:
				plant(Entities.Tree)
		else:
			if get_ground_type() != Grounds.Soil:
				till()
			if even and (num_items(Items.Wood) < 600 or num_items(Items.Wood) < num_items(Items.Carrot) * 2):
				plant(Entities.Tree)
			elif num_items(Items.Wood) > 10 and num_items(Items.Hay) > 10:
				plant(Entities.Carrot)
			elif even:
				plant(Entities.Tree)
			else:
				plant(Entities.Bush)
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
		move(North)
	move(East)

while True:
	ws = get_world_size()
	for i in range(ws):
		if can_harvest():
			harvest()
		x = get_pos_x()
		y = get_pos_y()
		even = (x + y) % 2 == 0
		if x < ws // 2:
			if get_ground_type() == Grounds.Soil:
				till()
		else:
			if get_ground_type() != Grounds.Soil:
				till()
			if even and num_items(Items.Wood) < 2500:
				plant(Entities.Tree)
				if get_water() < 0.5 and num_items(Items.Water) > 0:
					use_item(Items.Water)
			elif num_items(Items.Hay) > 350 and num_items(Items.Wood) > 350:
				plant(Entities.Carrot)
				if get_water() < 0.5 and num_items(Items.Water) > 0:
					use_item(Items.Water)
		move(North)
	move(East)

def do_giant_pumpkin():
	ws = get_world_size()
	for x in range(ws):
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			plant(Entities.Pumpkin)
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
			move(North)
		move(East)
	while num_items(Items.Carrot) >= 20:
		ws = get_world_size()
		ready = 0
		for x in range(ws):
			for y in range(ws):
				if get_ground_type() != Grounds.Soil:
					till()
				if get_entity_type() != Entities.Pumpkin:
					plant(Entities.Pumpkin)
					if get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
				elif can_harvest():
					ready = ready + 1
				else:
					if get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
				move(North)
			move(East)
		if ready == ws * ws:
			if num_items(Items.Weird_Substance) < 1200 and num_items(Items.Fertilizer) > 0:
				use_item(Items.Fertilizer)
			harvest()
			return

while True:
	if num_items(Items.Carrot) >= 2600 and num_items(Items.Pumpkin) < 6000:
		while num_items(Items.Carrot) >= 400 and num_items(Items.Pumpkin) < 6000:
			do_giant_pumpkin()
	ws = get_world_size()
	for x in range(ws):
		for y in range(ws):
			if can_harvest():
				harvest()
			px = get_pos_x()
			py = get_pos_y()
			even = (px + py) % 2 == 0
			if px < 3:
				if get_ground_type() == Grounds.Soil:
					till()
				if even and num_items(Items.Hay) > 2000 and num_items(Items.Wood) < 2500:
					plant(Entities.Tree)
			else:
				if get_ground_type() != Grounds.Soil:
					till()
				if even and (num_items(Items.Wood) < 3000 or num_items(Items.Hay) < 300):
					plant(Entities.Tree)
					if num_items(Items.Weird_Substance) < 1200 and num_items(Items.Fertilizer) > 5:
						use_item(Items.Fertilizer)
				elif num_items(Items.Hay) >= 300 and num_items(Items.Wood) >= 300:
					plant(Entities.Carrot)
				elif even:
					plant(Entities.Tree)
				else:
					plant(Entities.Bush)
				if get_water() < 0.5 and num_items(Items.Water) > 0:
					use_item(Items.Water)
			move(North)
		move(East)

def farm_power():
	ws = get_world_size()
	for x in range(ws):
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			plant(Entities.Sunflower)
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
			move(North)
		move(East)
	for p in [15, 14, 13, 12, 11, 10, 9, 8, 7]:
		for x in range(ws):
			for y in range(ws):
				if get_entity_type() == Entities.Sunflower:
					if measure() == p:
						while not can_harvest():
							if get_water() < 0.5 and num_items(Items.Water) > 0:
								use_item(Items.Water)
						harvest()
				move(North)
			move(East)

def farm_gold(target):
	dirs = [North, East, South, West]
	ws = get_world_size()
	while num_items(Items.Gold) < target and num_items(Items.Weird_Substance) >= ws:
		if can_harvest():
			harvest()
		plant(Entities.Bush)
		use_item(Items.Weird_Substance, ws)
		idx = 0
		while get_entity_type() != Entities.Treasure:
			if get_entity_type() != Entities.Hedge:
				break
			idx = (idx + 1) % 4
			while not can_move(dirs[idx]):
				idx = (idx - 1) % 4
			move(dirs[idx])
		if get_entity_type() == Entities.Treasure:
			harvest()

while True:
	if num_items(Items.Power) < 150 and num_items(Items.Carrot) >= 100:
		farm_power()
	if num_items(Items.Gold) < 6000 and num_items(Items.Weird_Substance) >= 64:
		farm_gold(6000)
	ws = get_world_size()
	for x in range(ws):
		for y in range(ws):
			px = get_pos_x()
			py = get_pos_y()
			even = (px + py) % 2 == 0
			if can_harvest():
				if even and get_entity_type() == Entities.Tree and num_items(Items.Weird_Substance) > 0 and num_items(Items.Weird_Substance) < 2000:
					use_item(Items.Weird_Substance)
				harvest()
			if px < 2:
				if get_ground_type() == Grounds.Soil:
					till()
			else:
				if get_ground_type() != Grounds.Soil:
					till()
				if even and (num_items(Items.Wood) < 6500 or num_items(Items.Weird_Substance) < 1000):
					plant(Entities.Tree)
				elif num_items(Items.Hay) >= 200 and num_items(Items.Wood) >= 200:
					plant(Entities.Carrot)
				elif even:
					plant(Entities.Tree)
				else:
					plant(Entities.Bush)
				if get_water() < 0.5 and num_items(Items.Water) > 0:
					use_item(Items.Water)
			move(North)
		move(East)

def sunflower_half(start_x, cols):
	ws = get_world_size()
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for x in range(cols):
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			plant(Entities.Sunflower)
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
			move(North)
		move(East)

def sunflower_east():
	ws = get_world_size()
	half = ws // 2
	sunflower_half(half, ws - half)

def farm_power():
	ws = get_world_size()
	half = ws // 2
	d1 = spawn_drone(sunflower_east)
	sunflower_half(0, half)
	if d1 != None:
		wait_for(d1)
	for p in [15, 14, 13, 12, 11, 10, 9, 8, 7]:
		for x in range(ws):
			for y in range(ws):
				if get_entity_type() == Entities.Sunflower:
					if measure() == p:
						while not can_harvest():
							if get_water() < 0.5 and num_items(Items.Water) > 0:
								use_item(Items.Water)
						harvest()
				move(North)
			move(East)

def pumpkin_half(start_x, cols):
	ws = get_world_size()
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for x in range(cols):
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			plant(Entities.Pumpkin)
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
			move(North)
		move(East)
	while num_items(Items.Carrot) >= 40:
		while get_pos_x() != start_x:
			move(West)
		ready = 0
		for x in range(cols):
			for y in range(ws):
				if get_ground_type() != Grounds.Soil:
					till()
				if get_entity_type() != Entities.Pumpkin:
					if can_harvest():
						harvest()
					plant(Entities.Pumpkin)
					if get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
				elif can_harvest():
					ready = ready + 1
				else:
					if get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
				move(North)
			move(East)
		if ready == cols * ws:
			return

def pumpkin_east():
	ws = get_world_size()
	half = ws // 2
	pumpkin_half(half, ws - half)

def do_giant_pumpkin():
	ws = get_world_size()
	half = ws // 2
	d1 = spawn_drone(pumpkin_east)
	pumpkin_half(0, half)
	if d1 != None:
		wait_for(d1)
	if can_harvest():
		harvest()

def basics_half(start_x, cols):
	ws = get_world_size()
	comp = []
	for i in range(ws * ws):
		comp.append(None)
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for step in range(6):
		while get_pos_x() != start_x:
			move(West)
		for x in range(cols):
			for y in range(ws):
				px = get_pos_x()
				py = get_pos_y()
				idx = px * ws + py
				even = (px + py) % 2 == 0
				if can_harvest():
					if even and get_entity_type() == Entities.Tree and num_items(Items.Weird_Substance) > 0 and num_items(Items.Weird_Substance) < 5000:
						use_item(Items.Weird_Substance)
					harvest()
				et = get_entity_type()
				if et == None or et == Entities.Grass or et == Entities.Dead_Pumpkin:
					want = comp[idx]
					comp[idx] = None
					if want != None:
						crop = want
					elif px == 0 or (px == 4 and num_items(Items.Hay) < 6000):
						crop = Entities.Grass
					elif even and (num_items(Items.Wood) < 15000 or num_items(Items.Weird_Substance) < 3000):
						crop = Entities.Tree
					elif num_items(Items.Hay) >= 300 and num_items(Items.Wood) >= 300:
						crop = Entities.Carrot
					elif even:
						crop = Entities.Tree
					else:
						crop = Entities.Grass
					if crop == Entities.Grass:
						if get_ground_type() == Grounds.Soil:
							till()
					elif crop == Entities.Carrot:
						if get_ground_type() != Grounds.Soil:
							till()
						if num_items(Items.Hay) >= 50 and num_items(Items.Wood) >= 50:
							plant(Entities.Carrot)
					else:
						plant(crop)
					if crop != Entities.Grass and get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
					c = get_companion()
					if c != None:
						c_type, c_pos = c
						cx, cy = c_pos
						if cx >= start_x and cx < start_x + cols:
							c_idx = cx * ws + cy
							if comp[c_idx] == None:
								comp[c_idx] = c_type
				move(North)
			move(East)

def basics_east():
	ws = get_world_size()
	half = ws // 2
	basics_half(half, ws - half)

def do_basics():
	ws = get_world_size()
	half = ws // 2
	d1 = spawn_drone(basics_east)
	basics_half(0, half)
	if d1 != None:
		wait_for(d1)

if get_entity_type() == Entities.Hedge or get_entity_type() == Entities.Treasure:
	harvest()

while True:
	if num_items(Items.Power) < 100 and num_items(Items.Carrot) >= 100:
		farm_power()
	if num_items(Items.Pumpkin) < 22000 and num_items(Items.Carrot) >= 5000:
		while num_items(Items.Pumpkin) < 22000 and num_items(Items.Carrot) >= 800:
			do_giant_pumpkin()
	do_basics()

def run_parallel_cols(fn):
	ws = get_world_size()
	n = max_drones()
	if n > ws:
		n = ws
	chunk = ws // n
	drones = []
	for i in range(1, n):
		sx = i * chunk
		c = chunk
		if i == n - 1:
			c = ws - sx
		def task():
			fn(sx, c)
		d = spawn_drone(task)
		if d != None:
			drones.append(d)
	fn(0, chunk)
	for d in drones:
		wait_for(d)

def run_parallel_rows(fn):
	ws = get_world_size()
	n = max_drones()
	if n > ws:
		n = ws
	chunk = ws // n
	drones = []
	for i in range(1, n):
		sy = i * chunk
		r = chunk
		if i == n - 1:
			r = ws - sy
		def task():
			fn(sy, r)
		d = spawn_drone(task)
		if d != None:
			drones.append(d)
	fn(0, chunk)
	for d in drones:
		wait_for(d)

def clear_cols(start_x, cols):
	ws = get_world_size()
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for c in range(cols):
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			if get_entity_type() != None:
				till()
				till()
			move(North)
		move(East)

def sunflower_cols(start_x, cols):
	ws = get_world_size()
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for x in range(cols):
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			if get_entity_type() != None:
				till()
				till()
			plant(Entities.Sunflower)
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
			move(North)
		move(East)

def farm_power():
	ws = get_world_size()
	run_parallel_cols(sunflower_cols)
	for p in [15, 14, 13, 12, 11, 10, 9, 8, 7]:
		def harvest_p_cols(start_x, cols):
			while get_pos_x() != start_x:
				move(East)
			while get_pos_y() != 0:
				move(North)
			for x in range(cols):
				for y in range(ws):
					if get_entity_type() == Entities.Sunflower:
						if measure() == p:
							while not can_harvest():
								if get_water() < 0.5 and num_items(Items.Water) > 0:
									use_item(Items.Water)
							harvest()
					move(North)
				move(East)
		run_parallel_cols(harvest_p_cols)

def cactus_cols(start_x, cols):
	ws = get_world_size()
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for c in range(cols):
		while get_pos_y() != 0:
			move(North)
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			if get_entity_type() != None:
				till()
				till()
			plant(Entities.Cactus)
			move(North)
		low = 0
		high = ws - 1
		while low < high:
			swapped = False
			while get_pos_y() < high:
				if measure() > measure(North):
					swap(North)
					swapped = True
				move(North)
			high = high - 1
			if not swapped:
				break
			swapped = False
			while get_pos_y() > low:
				if measure(South) > measure():
					swap(South)
					swapped = True
				move(South)
			low = low + 1
			if not swapped:
				break
		move(East)

def cactus_rows(start_y, rows):
	ws = get_world_size()
	while get_pos_y() != start_y:
		move(North)
	while get_pos_x() != 0:
		move(West)
	for r in range(rows):
		while get_pos_x() != 0:
			move(West)
		low = 0
		high = ws - 1
		while low < high:
			swapped = False
			while get_pos_x() < high:
				if measure() > measure(East):
					swap(East)
					swapped = True
				move(East)
			high = high - 1
			if not swapped:
				break
			swapped = False
			while get_pos_x() > low:
				if measure(West) > measure():
					swap(West)
					swapped = True
				move(West)
			low = low + 1
			if not swapped:
				break
		move(North)

def do_cactus_field():
	ws = get_world_size()
	run_parallel_cols(cactus_cols)
	run_parallel_rows(cactus_rows)
	for i in range(ws):
		while not can_harvest():
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
		move(North)
		move(East)
	harvest()

ax = -1
ay = -1
tail_len = 0

def step_dino(d):
	global ax
	global ay
	global tail_len
	if get_entity_type() == Entities.Apple:
		m = measure()
		if m != None:
			ax, ay = m
		tail_len = tail_len + 1
	return move(d)

def do_dinosaur():
	global ax
	global ay
	global tail_len
	run_parallel_cols(clear_cols)
	while get_pos_x() != 0:
		move(West)
	while get_pos_y() != 0:
		move(South)
	ax = -1
	ay = -1
	tail_len = 0
	change_hat(Hats.Dinosaur_Hat)
	ws = get_world_size()
	alive = True
	while alive and num_items(Items.Cactus) >= 20:
		for i in range(ws - 1):
			if not step_dino(North):
				alive = False
				break
		if not alive:
			break
		if not step_dino(East):
			break
		for i in range(ws - 2):
			if not step_dino(South):
				alive = False
				break
		if not alive:
			break
		col = 2
		returned_early = False
		while col <= ws - 2:
			if tail_len < 22 and ax >= 0 and ax < col:
				if not step_dino(South):
					alive = False
					break
				for i in range(col - 1):
					if not step_dino(West):
						alive = False
						break
				returned_early = True
				break
			if not step_dino(East):
				alive = False
				break
			if tail_len < 55 and ax != col and ax != col + 1:
				if not step_dino(East):
					alive = False
					break
			else:
				for i in range(ws - 2):
					if not step_dino(North):
						alive = False
						break
				if not alive:
					break
				if not step_dino(East):
					alive = False
					break
				for i in range(ws - 2):
					if not step_dino(South):
						alive = False
						break
				if not alive:
					break
			col = col + 2
		if not alive:
			break
		if not returned_early:
			if not step_dino(South):
				break
			for i in range(ws - 1):
				if not step_dino(West):
					alive = False
					break
	change_hat(Hats.Green_Hat)

def pumpkin_cols(start_x, cols):
	ws = get_world_size()
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for x in range(cols):
		for y in range(ws):
			if can_harvest():
				harvest()
			if get_ground_type() != Grounds.Soil:
				till()
			if get_entity_type() != None:
				till()
				till()
			plant(Entities.Pumpkin)
			if get_water() < 0.5 and num_items(Items.Water) > 0:
				use_item(Items.Water)
			move(North)
		move(East)
	while num_items(Items.Carrot) >= 50:
		while get_pos_x() != start_x:
			move(West)
		ready = 0
		for x in range(cols):
			for y in range(ws):
				if get_ground_type() != Grounds.Soil:
					till()
				if get_entity_type() != Entities.Pumpkin:
					if can_harvest():
						harvest()
					plant(Entities.Pumpkin)
					if get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
				elif can_harvest():
					ready = ready + 1
				else:
					if get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
				move(North)
			move(East)
		if ready == cols * ws:
			return

def do_giant_pumpkin():
	run_parallel_cols(pumpkin_cols)
	if can_harvest():
		harvest()

def basics_cols(start_x, cols):
	ws = get_world_size()
	comp = {}
	while get_pos_x() != start_x:
		move(East)
	while get_pos_y() != 0:
		move(North)
	for step in range(6):
		while get_pos_x() != start_x:
			move(West)
		for x in range(cols):
			for y in range(ws):
				px = get_pos_x()
				py = get_pos_y()
				pos = (px, py)
				even = (px + py) % 2 == 0
				if can_harvest():
					if even and get_entity_type() == Entities.Tree and num_items(Items.Weird_Substance) > 0 and num_items(Items.Weird_Substance) < 15000:
						use_item(Items.Weird_Substance)
					harvest()
				et = get_entity_type()
				if et == None or et == Entities.Grass or et == Entities.Dead_Pumpkin:
					want = None
					if pos in comp:
						want = comp[pos]
						comp.pop(pos)
					if want != None:
						crop = want
					elif x == 0 and num_items(Items.Hay) < 40000:
						crop = Entities.Grass
					elif even and (num_items(Items.Wood) < 50000 or num_items(Items.Weird_Substance) < 8000):
						crop = Entities.Tree
					elif num_items(Items.Hay) >= 500 and num_items(Items.Wood) >= 500:
						crop = Entities.Carrot
					elif even:
						crop = Entities.Tree
					else:
						crop = Entities.Grass
					if crop == Entities.Grass:
						if get_ground_type() == Grounds.Soil:
							till()
					elif crop == Entities.Carrot:
						if get_ground_type() != Grounds.Soil:
							till()
						if num_items(Items.Hay) >= 100 and num_items(Items.Wood) >= 100:
							plant(Entities.Carrot)
					else:
						plant(crop)
					if crop != Entities.Grass and get_water() < 0.5 and num_items(Items.Water) > 0:
						use_item(Items.Water)
					c = get_companion()
					if c != None:
						c_type, c_pos = c
						cx, cy = c_pos
						if cx >= start_x and cx < start_x + cols:
							if c_pos not in comp:
								comp[c_pos] = c_type
				move(North)
			move(East)

if get_entity_type() == Entities.Hedge or get_entity_type() == Entities.Treasure:
	harvest()

while True:
	if num_items(Items.Power) < 200 and num_items(Items.Carrot) >= 200:
		farm_power()
	if num_items(Items.Cactus) < 25000 and num_items(Items.Pumpkin) >= 400:
		do_cactus_field()
		unlock(Unlocks.Dinosaurs)
	if num_items(Items.Bone) < 30000 and num_items(Items.Cactus) >= 500:
		do_dinosaur()
		unlock(Unlocks.Polyculture)
	if num_items(Items.Pumpkin) < 70000 and num_items(Items.Carrot) >= 18000:
		unlock(Unlocks.Pumpkins)
		while num_items(Items.Pumpkin) < 70000 and num_items(Items.Carrot) >= 2000:
			do_giant_pumpkin()
	run_parallel_cols(basics_cols)
	unlock(Unlocks.Trees)
	unlock(Unlocks.Carrots)
	unlock(Unlocks.Grass)
	unlock(Unlocks.Watering)
	unlock(Unlocks.Fertilizer)