anchor.diff:  
   /datum/parsed_map
   	var/original_path
  +	var/map_format
   	/// The length of a key in this file. This is promised by the standard to be static
   	var/key_len = 0
  +	/// The length of a line in this file. Not promised by dmm but standard dmm uses it, so we can trust it
  +	var/line_len = 0
  +	/// If we've expanded world.maxx
  +	var/expanded_y = FALSE
  +	/// If we've expanded world.maxy
  +	var/expanded_x = FALSE
   	var/list/grid_models = list()
   	var/list/gridSets = list()
   	/// List of area types we've loaded AS A PART OF THIS MAP
  
positive.code: 		var/zcrd = gset.zcrd + z_offset - 1
  		if(!cropMap && ycrd > world.maxy)
  			world.maxy = ycrd // Expand Y here.  X is expanded in the loop below
  			has_expanded_world_maxy = TRUE
  		var/zexpansion = zcrd > world.maxz
  		var/no_afterchange = no_changeturf
  		if(zexpansion)
  
negative.code: 	var/set_space = FALSE
  	// Use where a list is needed, but where it will not be modified
  	// Used here to remove the cost of needing to make a new list for each fields entry when it's set manually later
  	var/static/list/default_list = GLOB.map_model_default // It's stupid, but it saves += list(list)
  	var/static/list/wrapped_default_list = list(default_list) // It's stupid, but it saves += list(list)
  	var/static/regex/var_edits = var_edits_tgm
  
  	var/path_to_init = ""
  	// Reference to the attributes list we're currently filling, if any
  	var/list/current_attributes
  	// If we are currently editing a path or not
  	var/editing = FALSE
  	for(var/model_key in grid_models)
  		// We're going to split models by newline
  		// This guarentees that each entry will be of interest to us
  		// Then we'll process them step by step
  		// Hopefully this reduces the cost from read_list that we'd otherwise have
  		var/list/lines = splittext(grid_models[model_key], "\n")
  		// Builds list of path/edits for later
  		// Of note: we cannot preallocate them to save time in list expansion later
  		// But fortunately lists allocate at least 8 entries normally anyway, and
  		// We are unlikely to have more then that many members
  		//will contain all members (paths) in model (in our example : /turf/unsimulated/wall)
  		var/list/members = list()
  		//will contain lists filled with corresponding variables, if any (in our example : list(icon_state = "rock") and list())
  		var/list/members_attributes = list()
  
  		/////////////////////////////////////////////////////////
  		//Constructing members and corresponding variables lists
  		////////////////////////////////////////////////////////
  		// string representation of the path to init
  		for(var/line in lines)
  			// We do this here to avoid needing to check at each return statement
  			// No harm in it anyway
  			CHECK_TICK
  
  			switch(line[length(line)])
  				if(";") // Var edit, we'll apply it
  					// Var edits look like \tname = value;
  					// I'm gonna try capturing them with regex, since it ought to be the fastest here
  					// Should hand back key = value
  					var_edits.Find(line)
  					var/value = parse_constant(var_edits.group[2])
  					if(istext(value))
  						value = apply_text_macros(value)
  					current_attributes[var_edits.group[1]] = value
  					continue // Keep on keeping on brother
  				if("{") // Start of an edit, and so also the start of a path
  					editing = TRUE
  					current_attributes = list() // Init the list we'll be filling
  					members_attributes += list(current_attributes)
  					path_to_init = copytext(line, 1, -1)
  				if(",") // Either the end of a path, or the end of an edit
  					if(editing) // it was the end of a path
  						editing = FALSE
  						continue
  					members_attributes += wrapped_default_list // We know this is a path, and we also know it has no vv's. so we'll just set this to the default list
  					// Drop the last char mind
  					path_to_init = copytext(line, 1, -1)
  				if("}") // Gotta be the end of an area edit, let's check to be sure
  					if(editing) // it was the end of an area edit (shouldn't do those anyhow)
  						editing = FALSE
  						continue
  					stack_trace("ended a line on JUST a }, with no ongoing edit. What? Area shit?")
  				else // If we're editing, this is a var edit entry. the last one in a stack, cause god hates me. Otherwise, it's an area
  					if(editing) // I want inline I want inline I want inline
  						// Var edits look like \tname = value;
  						// I'm gonna try capturing them with regex, since it ought to be the fastest here
  						// Should hand back key = value
  						var_edits.Find(line)
  						var/value = parse_constant(var_edits.group[2])
  						if(istext(value))
  							value = apply_text_macros(value)
  						current_attributes[var_edits.group[1]] = value
  						continue // Keep on keeping on brother
  
  					members_attributes += wrapped_default_list // We know this is a path, and we also know it has no vv's. so we'll just set this to the default list
  					path_to_init = line
  
  
  			// Alright, if we've gotten to this point, our string is a path
  			// Oh and we don't trim it, because we require no padding for these
  			// Saves like 1.5 deciseconds
  			var/atom_def = text2path(path_to_init) //path definition, e.g /obj/foo/bar
  
  			if(!ispath(atom_def, /atom)) // Skip the item if the path does not exist.  Fix your crap, mappers!
  				if(bad_paths)
  					// Rare case, avoid the var to save time most of the time
  					LAZYOR(bad_paths[copytext(line, 1, -1)], model_key)
  				continue
  			// Index is already incremented either way, just gotta set the path and all
  			members += atom_def
  
  		//check and see if we can just skip this turf
  		//So you don't have to understand this horrid statement, we can do this if
  		// 1. the space_key isn't set yet
  		// 2. no_changeturf is set
  		// 3. there are exactly 2 members
  		// 4. with no attributes
  		// 5. and the members are world.turf and world.area
  		// Basically, if we find an entry like this: "XXX" = (/turf/default, /area/default)
  		// We can skip calling this proc every time we see XXX
  		if(!set_space \
  			&& no_changeturf \
  			&& members_attributes.len == 2 \
  			&& members.len == 2 \
  			&& members_attributes[1] == default_list \
  			&& members_attributes[2] == default_list \
  			&& members[2] == world.area \
  			&& members[1] == world.turf
  		)
  			set_space = TRUE
  			.[SPACE_KEY] = model_key
  			continue
  
  		.[model_key] = list(members, members_attributes)
  	return .
  
  /// Builds key caches for general formats
  /// Slower then the proc above, tho it could still be optimized slightly. it's just not a priority
  /// Since we don't run DMM maps, ever.
  /datum/parsed_map/proc/dmm_build_cache(no_changeturf, bad_paths=null)
  	if(modelCache && !bad_paths)
  		return modelCache
  	. = modelCache = list()
  	var/list/grid_models = src.grid_models
  	var/set_space = FALSE
  	// Use where a list is needed, but where it will not be modified
  	// Used here to remove the cost of needing to make a new list for each fields entry when it's set manually later
  	var/static/list/default_list = list(GLOB.map_model_default)
  	for(var/model_key in grid_models)
  		//will contain all members (paths) in model (in our example : /turf/unsimulated/wall)
  		var/list/members = list()
  		//will contain lists filled with corresponding variables, if any (in our example : list(icon_state = "rock") and list())
  		var/list/members_attributes = list()
  
  		var/model = grid_models[model_key]
  		/////////////////////////////////////////////////////////
  		//Constructing members and corresponding variables lists
  		////////////////////////////////////////////////////////
  
  		var/model_index = 1
  		while(model_path.Find(model, model_index))
  			var/variables_start = 0
  			var/member_string = model_path.group[1]
  			model_index = model_path.next
  			//findtext is a bit expensive, lets only do this if the last char of our string is a } (IE: we know we have vars)
  			//this saves about 25 miliseconds on my machine. Not a major optimization
  			if(member_string[length(member_string)] == "}")
  