diff --git a/src/PuzzleScript/Compiler.rsc b/src/PuzzleScript/Compiler.rsc
index 422852a..ea3a952 100644
--- a/src/PuzzleScript/Compiler.rsc
+++ b/src/PuzzleScript/Compiler.rsc
@@ -80,6 +80,7 @@ alias Rule = tuple[
 	set[str] directions,
 	list[str] left,
 	list[str] right,
+	list[list[Coords]] indexes,
 	int used,
 	RULEDATA original
 ];
@@ -91,6 +92,7 @@ Rule new_rule(RULEDATA r)
 		{}, 
 		[], 
 		[],
+		[],
 		0, 
 		r
 	>;
@@ -166,7 +168,7 @@ data RuleContent
 alias RulePart = list[RuleContent];
 
 // matching & replacement
-str empty_layer(int index, bool _) = "[ *layer<index> ]";
+str empty_layer(int index, bool _) = "[ *prefix_lines<index>, \n\t\t[ *prefix_objects<index>, \n\t\t*suffix_objects<index>], \n\t*suffix_lines<index> ]";
 str empty_level(bool _: true) = "[ *level ]";
 
 str layer(int index, list[str] stuff, bool is_pattern) 
@@ -177,7 +179,8 @@ str line(int index, list[str] stuff, bool _) {
 	return "[ *prefix_objects<index>, \n\t\t\t<compiled_stuff>, \n\t\t*suffix_objects<index> ]";
 }
 
-str unique(Coords index) = "<index.x>_<index.y>_<index.z>";
+//str unique(Coords index) = "<index.x>_<index.y>_<index.z>";
+str unique(Coords index) = "<index.x>_<index.z>";
 
 //ANY CHANGES TO THE VALUES ON THE RIGHT MUST BE MIRRORED IN THE FUNCTION BELOW
 map[str, str] relative_mapping = (
@@ -216,7 +219,9 @@ str absolufy(str force) {
 }
 
 str coords(Coords index, bool _: true)
-	= "Coords coords<unique(index)> : \<xcoord<index.x>, ycoord<index.x>, zcoord<unique(index)>\>";
+	//= "Coords coords<unique(index)> : \<xcoord<index.x>, ycoord<index.x>, zcoord<unique(index)>\>";
+	//= "Coords coords<unique(index)>";
+	= "\<xcoord<index.x> , ycoord<index.x>, <index.z>\>";
 
 str object(Coords index, RuleReference ref, Engine engine, bool is_pattern: true) {
 	str names = intercalate("|", ref.objects);
@@ -249,7 +254,8 @@ str absolufy(str force, Coords index) {
 }
 
 str coords(Coords index, bool _: false)
-	= "coords<unique(index)>";	
+	//= "coords<unique(index)>";
+	= "\<xcoord<index.x>, ycoord<index.x>, <index.z>\>";	
 	
 str transparent(Coords index)
 	= "transparent(\"trans\", -1, coords<unique(index)>)";
@@ -289,6 +295,7 @@ str format_compiled_layers(list[list[str]] compiled_layer, bool is_pattern){
 Rule compile_rulepart_left(Rule rule, Engine engine, RulePart left_contents, RulePart right_contents){
 	list[list[str]] compiled_layer = [];
 	list[set[str]] layers = engine.layers;
+	list[Coords] indexes = [];
 	
 	for (int b <- [0..size(layers)]){
 		set[str] lyr = layers[b];
@@ -302,6 +309,7 @@ Rule compile_rulepart_left(Rule rule, Engine engine, RulePart left_contents, Rul
 					Coords index = <i, j, b>;
 					RuleReference ref = refs[j];
 					if (!any(str x <- ref.objects, x in lyr)) continue;
+					indexes += [index];
 			        if (ref.force in ["none", "stationary", "no"]){
 			            compiled_lines += [object(index, ref, engine, true)];
 			        } else {
@@ -321,6 +329,7 @@ Rule compile_rulepart_left(Rule rule, Engine engine, RulePart left_contents, Rul
 		compiled_layer += [compiled_lines];
 	}
 	
+	rule.indexes += [indexes];
 	rule.left += [format_compiled_layers(compiled_layer, true)];
 	return rule;
 }
diff --git a/src/PuzzleScript/Engine.rsc b/src/PuzzleScript/Engine.rsc
index f3f28e2..dc0dc13 100644
--- a/src/PuzzleScript/Engine.rsc
+++ b/src/PuzzleScript/Engine.rsc
@@ -89,19 +89,49 @@ list[Layer] rotate_level(list[Layer] layers){
 	return new_layers;
 }
 
-str format_replacement(str pattern, str replacement, list[Layer] layers) {
-	return "
-	'list[Layer] layers = <layers>;
-	'if (<pattern> := layers) layers = <replacement>;
-	'layers;
-	'";
+str format_coords(list[Coords] indexes) {
+	list[str] coords = [];
+	
+	for (Coords index <- indexes){
+		str root = "coords<unique(index)>";
+		Coords neighbor = <index.x + 1, index.y, index.z>;
+		str neighbor_root = "coords<unique(neighbor)>";
+		if (!(neighbor in indexes)) continue;
+
+		coords += ["(<root>.x == (<neighbor_root>.x - 1) && <root>.y == <neighbor_root>.y)"];
+	}	
+	
+	if (isEmpty(coords)) return "true";
+	return intercalate(" && ", coords);
 }
 
-str format_pattern(str pattern, list[Layer] layers){
-	return "
+str format_eval(str pattern, str replacement, list[Layer] layers, list[Coords] indexes, bool is_match){
+	str e = "
+	'import IO;
+	'bool is_match = false;
 	'list[Layer] layers  = <layers>;
-	'<pattern> := layers;
-	'";
+	'for (<pattern> := layers){
+	'	println(xcoord0);
+	'	println(ycoord0);
+	'	if (<format_coords(indexes)>) {
+	'		<if (is_match){>
+	'		is_match = true;
+	'		<} else {>
+	'		layers = <replacement>;
+	'		<}>
+	' 		break;
+	'	}
+	'}
+	'<if (is_match){>
+	'is_match;
+	'<} else {>
+	'layers;
+	'<}>
+	'";	
+	
+	println(e);
+	
+	return e;
 }
 
 map[str, list[str]] directional_absolutes = (
@@ -111,8 +141,11 @@ map[str, list[str]] directional_absolutes = (
 	"up" :    ["up",    "down",  "right", "left" ] // ^
 );
 
-bool eval_pattern(str pattern, str relatives)
-	=	eval(#bool, [EVAL_PRESET, relatives, pattern]).val;
+bool eval_pattern(str pattern, str relatives) {
+	bool v = eval(#bool, [EVAL_PRESET, relatives, pattern]).val;
+	if(v) println(pattern);
+	return v;
+}
 
 list[str] ROTATION_ORDER = ["right", "up", "left", "down"];
 tuple[Engine, Level, Rule] apply_rule(Engine engine, Level level, Rule rule){
@@ -122,7 +155,7 @@ tuple[Engine, Level, Rule] apply_rule(Engine engine, Level level, Rule rule){
 	for (str dir <- ROTATION_ORDER){
 		if (dir in rule.directions){
 			str relatives = format_relatives(directional_absolutes[dir]);
-			while (all(str pattern <- rule.left, eval_pattern(format_pattern(pattern, layers), relatives))){
+			while (all(int i <- [0..size(rule.left)], eval_pattern(format_eval(rule.left[i], "", layers, rule.indexes[i], true), relatives))){
 				rule.used += 1;
 				int index = loops % size(rule.left);
 				
@@ -130,14 +163,18 @@ tuple[Engine, Level, Rule] apply_rule(Engine engine, Level level, Rule rule){
 					break;
 				}
 				
-				layers = eval(#list[Layer], [EVAL_PRESET, relatives, format_replacement(rule.left[index], rule.right[index], layers)]).val;
+				for (int i <- [0..size(rule.left)]){
+					layers = eval(#list[Layer], [EVAL_PRESET, relatives, format_eval(rule.left[i], rule.right[i], layers, rule.indexes[i], false)]).val;
+				}
+
 				loops += 1;
 				
-				if (index == 0 && layers == level.layers){
-					break;
-				} else if (loops > MAX_LOOPS) {
+				if (level.layers == layers || loops > MAX_LOOPS){
 					break;
+				} else {
+					changed = true;
 				}
+				
 			}
 		}
 		
@@ -195,7 +232,7 @@ tuple[Engine, Level] do_turn(Engine engine, Level level : level, str input){
 	
 	level = do_move(level);
 	
-	// post-run after the move
+	// post-run after the move (late rules)
 	do {
 		engine.again = false;
 		<engine, level> = rewrite(engine, level, true);
@@ -409,22 +446,22 @@ void print_level(Level l : level){
 	str pixel(str p : "trans") = ".";
 	default str pixel(str p) = p[0];
 	
-	//for (Layer lyr <- l.layers){
-	//	for (Line line <- lyr) {
-	//		print(intercalate("", [pixel(x.name) | x <- line]));
-	//		//print("   ");
-	//		//print(intercalate(" ", line));
-	//		println();
-	//	}
-	//	println();
-	//}
-	
-	for (Line line <- l.layers[-1]) {
-		print(intercalate("", [pixel(x.name) | x <- line]));
-		//print("   ");
-		//print(intercalate(" ", line));
+	for (Layer lyr <- l.layers){
+		for (Line line <- lyr) {
+			print(intercalate("", [pixel(x.name) | x <- line]));
+			print("   ");
+			print(intercalate(", ", [x.name | x <- line, x.name != "trans"]));
+			println();
+		}
 		println();
 	}
+	
+	//for (Line line <- l.layers[-3]) {
+	//	print(intercalate("", [pixel(x.name) | x <- line]));
+	//	//print("   ");
+	//	//print(intercalate(" ", line));
+	//	println();
+	//}
 	println();
 }