View difference between Paste ID: gnb2N5j4 and nSXtyEwa

 // name, lvl, modifiers, weights
 var rawData = `MapAtlasMapsHave20PercentQuality	1	"Maps have 20% Quality
 Unique Bosses deal 20% increased Damage"	default 1,000
 MapAtlasContainsAdditionalRandomBoss	1	Areas are inhabited by an additional Invasion Boss	"hall_of_grandmasters 0
 default 1,000"
 MapAtlasClustersOfBloodwormBarrels	1	Areas contain 30 additional Clusters of Mysterious Barrels	default 850
 MapAtlasPhysicalDamageAndPacks_	1	"Areas contain additional Monsters that deal Physical Damage
 Players and Monsters take 10% increased Physical Damage"	"no_monster_packs 0
 default 1,000"
 MapAtlasHighValueEnemiesOnOwnTeam	1	Areas contain hunted traitors	"no_monster_packs 0
 default 100"
 MapAtlasMagicAndRareMapsHaveAdditionalPacks	1	"Magic Maps contain additional Magic Monsters
 Rare Maps contain additional Rare Monsters
 Normal Maps contain additional Normal Monsters"	"unique_map 0
 no_monster_packs 0
 default 1,000"
 MapAtlasMoveAttackCastSpeed	1	"20% increased Player and Monster Movement Speed
 20% increased Monster Attack Speed
 20% increased Monster Cast Speed"	default 1,000
 MapAtlasMontersThatConvertOnDeath__	1	Areas contain additional Monsters that Convert when Killed	"no_monster_packs 0
 default 1,000"
 MapAtlasUnIDedMapsGrantQuantity	1	"30% increased Quantity of Items found in Unidentified Maps
 Found Items drop Identified in Identified Maps
 15% increased Pack Size in Unidentified Maps"	default 1,000
 MapAtlasReducedReflectedDamageTakenMirroredRares	1	"Players cannot take Reflected Damage
 Areas contain additional Packs with Mirrored Rare Monsters"	default 1,000
 MapAtlasPlayersDamageDealtAndTakenWhileStationary_	1	"Players deal 100% increased Damage while stationary
 Players take 10% increased Damage while stationary"	"vaults_of_atziri 0
 default 1,000"
 MapAtlasFireDamageAndPacks	1	"Areas contain additional Monsters that deal Fire Damage
 Players and Monsters take 10% increased Fire Damage"	"no_monster_packs 0
 default 1,000"
 MapAtlasGroundHaste	1	Areas contain Slipstreams	default 1,000
 MapAtlasInstantFlasksAndHealingMonsters	1	"Life and Mana Recovery from Flasks are instant
 Areas contain additional Monsters that Heal"	default 1,000
 MapAtlasOnslaughtWhenHitAndOnslaughtEffect	1	"Players and Monsters have Onslaught if they have been Hit Recently
 100% increased effect of Onslaught on Players and Monsters"	"vaults_of_atziri 0
 default 1,000"
 MapAtlasColdDamageAndPacks	1	"Areas contain additional Monsters that deal Cold Damage
 Players and Monsters take 10% increased Cold Damage"	"no_monster_packs 0
 default 1,000"
 MapAtlasStrongboxMonstersEnrageAndDrops	1	"Strongbox Monsters have 500% increased Item Quantity
 Strongbox Monsters are Enraged
 Areas contain an extra Strongbox"	"hall_of_grandmasters 0
 no_strongboxes 0
 default 1,000"
 MapAtlasMagicPackSize	1	30% increased Magic Pack Size	"no_monster_packs 0
 default 1,000"
 MapAtlasBodyguardsAndBossMapDrops	1	"Unique Bosses are accompanied by Bodyguards
 An additional Map drops on Completing Areas"	"no_boss 0
 default 1,000"
 MapAtlasLightningDamageAndPacks	1	"Areas contain additional Monsters that deal Lightning Damage
 Players and Monsters take 10% increased Lightning Damage"	"no_monster_packs 0
 default 1,000"
 MapAtlasPoisonEffectsAndParasites	1	"Players deal 10% increased Damage for each Poison on them
 Players have 5% increased Movement Speed for each Poison on them
 Areas contain additional Poisonous Monsters"	default 1,000
 MapAtlasRogueExilesDamageAndDropAdditionalJewels	1	"Rogue Exiles deal 20% increased Damage
 Rogue Exiles have 20% increased Maximum Life
 Rogue Exiles drop 2 additional Jewels
 Areas are inhabited by 1 additional Rogue Exile"	"no_monster_packs 0
 default 1,000"
 MapAtlasCurseEffectOnPlayersAndMonsters	73	"20% reduced Effect of Curses on Monsters
 60% reduced Effect of Curses on Players"	"vaults_of_atziri 0
 default 1,000"
 MapAtlasContainsZanaMission	73	Areas contain Zana	"unique_map 0
 default 200"
 MapAtlasMapQualityBonusAlsoAppliesToRarity	73	"Quality bonus of Maps also applies to Rarity of Items found
 Unique Bosses have 20% increased Life"	default 1,000
 MapAtlasStrongboxesAreCorruptedAndUnided	73	"Strongboxes in Areas are Corrupted
 Areas contain an extra Strongbox
 Strongboxes in Areas are at least Rare Rarity"	"no_strongboxes 0
 default 200"
 MapAtlasChaosDamageAndPacks_	73	"Areas contain additional Monsters that deal Chaos Damage
 Players and Monsters take 10% increased Chaos Damage"	"no_monster_packs 0
 default 1,000"
 MapAtlasUniqueMonstersDropCorruptedItems	73	Unique Monsters drop Corrupted Items	"vaults_of_atziri 0
 hall_of_grandmasters 0
 default 200"
 MapAtlasCorruptedMapBossesDropAdditionalVaalItems	78	"Unique Bosses of Corrupted Maps drop an additional Vaal Item
 Found Items have a 5% chance to drop Corrupted in Areas"	default 1,000
 MapAtlasBloodlinesDropAdditionalCurrency	78	Nemesis Monsters drop 3 additional Currency Items	"no_monster_packs 0
 default 200"
 MapAtlasFishy	78	Areas are Alluring	default 10`;
 
 // tier "enum"
 var tier = {
-	WHITE: 1,
+    WHITE: 1,
-  YELLOW: 73,
+    YELLOW: 73,
-  RED: 78,
+    RED: 78,
 };
 
 function getSextantCost(tier) {
-	switch ( tier ) {
+    switch (tier) {
-  	case 1:
+        case 1:
-    	return 2.0; // 4 chaos
+            return 2.0; // 4 chaos
-  	case 73:
+        case 73:
-    	return 4.0; // 5 chaos
+            return 4.0; // 5 chaos
-    case 78:
+        case 78:
-    	return 8.0; // 6 chaos
+            return 8.0; // 6 chaos
-  }
+
 }
 
 var maxIterations = 500000;
 
 var mapData = {
-	"Shaped Primordial Pool": {
+    "Shaped Primordial Pool": {
-  	tier: tier.YELLOW,
+        tier: tier.YELLOW,
-    adjacent: [
+        adjacent: [
-    	"Cavern",
+            "Cavern",
-      "Waste Pool",
+            "Waste Pool",
-      "Phantasmagoria",
+            "Phantasmagoria",
-      "Burial Chambers",
+            "Burial Chambers",
-    ]
+        ]
-  },
+    },
-	"Canyon": {
+    "Canyon": {
-  	tier: tier.YELLOW,
+        tier: tier.YELLOW,
-    adjacent: [
+        adjacent: [
-      "Waste Pool",
+            "Waste Pool",
-    ]
+        ]
-  },
+    },
-	"Vaal City": {
+    "Vaal City": {
-  	tier: tier.YELLOW,
+        tier: tier.YELLOW,
-    adjacent: [
+        adjacent: [
-    	"Burial Chambers",
+            "Burial Chambers",
-    	"Vaults of Atziri",
+            "Vaults of Atziri",
-    	"Arachnid Tomb",
+            "Arachnid Tomb",
-    	"Olmec's Sanctum",
+            "Olmec's Sanctum",
-    	"Shore",
+            "Shore",
-    	"Catacombs",
+            "Catacombs",
-    ]
+        ]
-  },
+    },
-	"Arachnid Tomb": {
+    "Arachnid Tomb": {
-  	tier: tier.YELLOW,
+        tier: tier.YELLOW,
-    adjacent: [
+        adjacent: [
-    	"Vaults of Atziri",
+            "Vaults of Atziri",
-    	"Shore",
+            "Shore",
-      "Vaal City",
+            "Vaal City",
-      "Vaal Pyramid",
+            "Vaal Pyramid",
-    ]
+        ]
-  },
+    },
-	"Shore": {
+    "Shore": {
-  	tier: tier.YELLOW,
+        tier: tier.YELLOW,
-    adjacent: [
+        adjacent: [
-    	"Arachnid Tomb",
+            "Arachnid Tomb",
-      "Vaal City",
+            "Vaal City",
-      "Catacombs",
+            "Catacombs",
-      "Olmec's Sanctum",
+            "Olmec's Sanctum",
-    ]
+        ]
-  },
+    },
-	"Catacombs": {
+    "Catacombs": {
-  	tier: tier.YELLOW,
+        tier: tier.YELLOW,
-    adjacent: [
+        adjacent: [
-      "Vaal City",
+            "Vaal City",
-      "Shore",
+            "Shore",
-      "Olmec's Sanctum",
+            "Olmec's Sanctum",
-    ]
+        ]
-  },
+    },
-	"Olmec's Sanctum": {
+    "Olmec's Sanctum": {
-  	tier: tier.YELLOW,
+        tier: tier.YELLOW,
-    adjacent: [
+        adjacent: [
-      "Vaal City",
+            "Vaal City",
-      "Shore",
+            "Shore",
-      "Catacombs",
+            "Catacombs",
-    ]
+        ]
-  },
+    },
-	"Vaal Pyramid": {
+    "Vaal Pyramid": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Phantasmagoria",
+            "Phantasmagoria",
-      "Burial Chambers",
+            "Burial Chambers",
-      "Marshes",
+            "Marshes",
-      "Vaults of Atziri",
+            "Vaults of Atziri",
-      "Arachnid Tomb",
+            "Arachnid Tomb",
-    ]
+        ]
-  },
+    },
-	"Marshes": {
+    "Marshes": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Phantasmagoria",
+            "Phantasmagoria",
-      "Vaal Pyramid",
+            "Vaal Pyramid",
-    ]
+        ]
-  },
+    },
-	"Phantasmagoria": {
+    "Phantasmagoria": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Shaped Primordial Pool",
+            "Shaped Primordial Pool",
-      "Vaal Pyramid",
+            "Vaal Pyramid",
-      "Marshes",
+            "Marshes",
-    ]
+        ]
-  },
+    },
-	"Burial Chambers": {
+    "Burial Chambers": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Shaped Primordial Pool",
+            "Shaped Primordial Pool",
-      "Vaal Pyramid",
+            "Vaal Pyramid",
-      "Vaults of Atziri",
+            "Vaults of Atziri",
-      "Vaal City",
+            "Vaal City",
-    ]
+        ]
-  },
+    },
-	"Cavern": {
+    "Cavern": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Shaped Primordial Pool",
+            "Shaped Primordial Pool",
-      "Waste Pool",
+            "Waste Pool",
-    ]
+        ]
-  },
+    },
-	"Waste Pool": {
+    "Waste Pool": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Shaped Primordial Pool",
+            "Shaped Primordial Pool",
-      "Cavern",
+            "Cavern",
-      "Canyon",
+            "Canyon",
-      "Channel",
+            "Channel",
-    ]
+        ]
-  },
+    },
-	"Channel": {
+    "Channel": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Waste Pool",
+            "Waste Pool",
-      "Acid Lakes",
+            "Acid Lakes",
-      "Mesa",
+            "Mesa",
-      "Factory",
+            "Factory",
-    ]
+        ]
-  },
+    },
-	"Vaults of Atziri": {
+    "Vaults of Atziri": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Burial Chambers",
+            "Burial Chambers",
-      "Vaal City",
+            "Vaal City",
-      "Arachnid Tomb",
+            "Arachnid Tomb",
-      "Vaal Pyramid",
+            "Vaal Pyramid",
-    ]
+        ]
-  },
+    },
-	"Acid Lakes": {
+    "Acid Lakes": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Channel",
+            "Channel",
-      "Factory",
+            "Factory",
-    ]
+        ]
-  },
+    },
-	"Mesa": {
+    "Mesa": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Channel",
+            "Channel",
-    ]
+        ]
-  },
+    },
-	"Factory": {
+    "Factory": {
-  	tier: tier.WHITE,
+        tier: tier.WHITE,
-    adjacent: [
+        adjacent: [
-      "Channel",
+            "Channel",
-      "Acid Lakes",
+            "Acid Lakes",
-    ]
+        ]
-  },
+    },
 };
 
 var goodMods = {
-  "MapAtlasFireDamageAndPacks": true,
+    "MapAtlasFireDamageAndPacks": true,
-  "MapAtlasColdDamageAndPacks": true,
+    "MapAtlasColdDamageAndPacks": true,
-  "MapAtlasLightningDamageAndPacks": true,
+    "MapAtlasLightningDamageAndPacks": true,
-  "MapAtlasPhysicalDamageAndPacks_": true,
+    "MapAtlasPhysicalDamageAndPacks_": true,
-  "MapAtlasChaosDamageAndPacks_": true,
+    "MapAtlasChaosDamageAndPacks_": true,
-  "MapAtlasMontersThatConvertOnDeath__": true,
+    "MapAtlasMontersThatConvertOnDeath__": true,
-  "MapAtlasInstantFlasksAndHealingMonsters": true,
+    "MapAtlasInstantFlasksAndHealingMonsters": true,
-  "MapAtlasMagicAndRareMapsHaveAdditionalPacks": true,
+    "MapAtlasMagicAndRareMapsHaveAdditionalPacks": true,
-  "MapAtlasHighValueEnemiesOnOwnTeam": true,
+    "MapAtlasHighValueEnemiesOnOwnTeam": true,
-  "MapAtlasPoisonEffectsAndParasites": true,
+    "MapAtlasPoisonEffectsAndParasites": true,
-	"MapAtlasClustersOfBloodwormBarrels": true,
+    "MapAtlasClustersOfBloodwormBarrels": true,
-  "MapAtlasClustersOfParasiteBarrels": true,
+    "MapAtlasClustersOfParasiteBarrels": true,
-  "MapAtlasClustersOfWealthyBarrels": true,
+    "MapAtlasClustersOfWealthyBarrels": true,
-  "MapAtlasClustersOfBeaconBarrels": true,
+    "MapAtlasClustersOfBeaconBarrels": true,
-  "MapAtlasClustersOfVolatileBarrels": true,
+    "MapAtlasClustersOfVolatileBarrels": true,
-  "MapAtlasMagicPackSize": true,
+    "MapAtlasMagicPackSize": true,
-  "MapAtlasUniqueMonstersDropCorruptedItems": true,
+    "MapAtlasUniqueMonstersDropCorruptedItems": true,
-  "MapAtlasBloodlinesDropAdditionalCurrency": true,
+    "MapAtlasBloodlinesDropAdditionalCurrency": true,
-  "MapAtlasReducedReflectedDamageTakenMirroredRares": true,
+    "MapAtlasReducedReflectedDamageTakenMirroredRares": true,
-  "MapAtlasStrongboxesAreCorruptedAndUnided": true,
+    "MapAtlasStrongboxesAreCorruptedAndUnided": true,
-  "MapAtlasStrongboxMonstersEnrageAndDrops": true,
+    "MapAtlasStrongboxMonstersEnrageAndDrops": true,
 }
 
-var parsed = rawData.match( /.+\t.+\t[^\t]+\t[^\t]+\n/g );
+var parsed = rawData.match(/.+\t.+\t[^\t]+\t[^\t]+\n/g);
 
-for ( var i = 0; i < parsed.length; i++ ) {
+for (var i = 0; i < parsed.length; i++) {
-	var str = parsed[i];
+    var str = parsed[i];
-
+
-  str = str.match( /[^\t]+/g );
+    str = str.match(/[^\t]+/g);
-
+
-  parsed[i] = {
+    parsed[i] = {
-  	name: str[0],
+        name: str[0],
-    level: parseInt(str[1]),
+        level: parseInt(str[1]),
-    mods: str[2].match( /[^\n"]+/g ),
+        mods: str[2].match(/[^\n"]+/g),
-    weights: str[3].match( /[^\n"]+/g ),
+        weights: str[3].match(/[^\n"]+/g),
-  }
+
-
+
-  var weightsObj = {};
+    var weightsObj = {};
-
+
-  for ( var j = 0; j < parsed[i].weights.length; j++ ) {
+    for (var j = 0; j < parsed[i].weights.length; j++) {
-  	var r = parsed[i].weights[j].split( /\s/ );
+        var r = parsed[i].weights[j].split(/\s/);
-    weightsObj[r[0]] = parseInt( r[1].replace(",", "") );
+        weightsObj[r[0]] = parseInt(r[1].replace(",", ""));
-  }
+
-
+
-  parsed[i].weights = weightsObj;
+    parsed[i].weights = weightsObj;
 }
 
 var maps = {};
 
 // Map prototype -------------------------------------------------
 
 // constructor
 
 function Map(name, tier, adj, activeMod) {
-	this.name = name;
+    this.name = name;
-  this.tier = tier;
+    this.tier = tier;
-  this.sextantCost = getSextantCost( this.tier );
+    this.sextantCost = getSextantCost(this.tier);
-  //console.log( this.name + " sextant cost is " + this.sextantCost + "c.");
+    //console.log( this.name + " sextant cost is " + this.sextantCost + "c.");
-  if ( activeMod ) {
+    if (activeMod) {
-  	for ( var mod in parsed ) {
+        for (var mod in parsed) {
-    	if ( mod.name == activeMod ) {
+            if (mod.name == activeMod) {
-      	this.mod = mod;
+                this.mod = mod;
                 break;
-      }
+            }
         }
-  }
+
-  this.adjacent = adj;
+    this.adjacent = adj;
-
+
-  maps[this.name] = this;
+    maps[this.name] = this;
 }
 
-Map.prototype.getBlockedMods = function( log ) {
+Map.prototype.getBlockedMods = function(log) {
-	if ( log ) { console.log("Blocked mods for " + this.name + ":"); }
+    if (log) {
-	var blocked = {};
+        console.log("Blocked mods for " + this.name + ":");
-	for ( var i in this.adjacent ) {
+
-  	if ( this.adjacent[i].mod ) {
+    var blocked = {};
-    	if ( log ) { console.log(this.adjacent[i].name + " blocks " + this.adjacent[i].mod.name); }
+    for (var i in this.adjacent) {
-  		blocked[this.adjacent[i].mod.name] = true;
+        if (this.adjacent[i].mod) {
             if (log) {
-
+                console.log(this.adjacent[i].name + " blocks " + this.adjacent[i].mod.name);
-    for ( var j in this.adjacent[i].adjacent ) {
+            }
-    	if ( this.adjacent[i].adjacent[j].mod ) {
+            blocked[this.adjacent[i].mod.name] = true;
-    		if ( log ) { console.log(this.adjacent[i].adjacent[j].name + " blocks " + this.adjacent[i].adjacent[j].mod.name); }
+        }
-    		blocked[this.adjacent[i].adjacent[j].mod.name] = true;
+
-      }
+        for (var j in this.adjacent[i].adjacent) {
             if (this.adjacent[i].adjacent[j].mod) {
-  }
+                if (log) {
-  return blocked;
+                    console.log(this.adjacent[i].adjacent[j].name + " blocks " + this.adjacent[i].adjacent[j].mod.name);
                 }
                 blocked[this.adjacent[i].adjacent[j].mod.name] = true;
             }
-	var blocked = this.getBlockedMods();
+        }
     }
-	return parsed.filter( function(mod) {
+    return blocked;
-  	if ( this.tier < mod.level || blocked[mod.name] || mod == this.mod ) {
+
-    	return false;
+
 Map.prototype.getFilteredModList = function() {
-    return true;
+    var blocked = this.getBlockedMods();
-  } );
+
     return parsed.filter(function(mod) {
         if (this.tier < mod.level || blocked[mod.name] || mod == this.mod) {
             return false;
-	var mods = this.getFilteredModList();
+        }
-
+        return true;
-  var totalWeight = mods.reduce( function( acc, val ) {
+
-  	return acc + val.weights.default;
+
-  }, 0);
+
-	var roll = Math.random() * totalWeight;
+
-  var sum = 0;
+    var mods = this.getFilteredModList();
-
+
-  for ( var mod in mods ) {
+    var totalWeight = mods.reduce(function(acc, val) {
-  	sum += mods[mod].weights.default;
+        return acc + val.weights.default;
-  	if ( roll < sum ) {
+    }, 0);
-    	this.mod = mods[mod];
+    var roll = Math.random() * totalWeight;
-      //console.log("Applied '" + this.mod.name + "' to " + this.name + ".");
+    var sum = 0;
-      return this.sextantCost;
+
     for (var mod in mods) {
-  }
+        sum += mods[mod].weights.default;
         if (roll < sum) {
             this.mod = mods[mod];
-Map.prototype.isAdjacentTo = function( name ) {
+            //console.log("Applied '" + this.mod.name + "' to " + this.name + ".");
-  return Boolean( this.adjacent.find( map => map.name === name ) );
+            return this.sextantCost;
         }
     }
 }
 
 Map.prototype.isAdjacentTo = function(name) {
     return Boolean(this.adjacent.find(map => map.name === name));
-function Atlas( maps ) {
+
-	this.maps = maps;
+
-	this.savedMods = {};
+
-
+
-	for ( var map in this.maps ) {
+
-  	this.savedMods[this.maps[map].name] = this.maps[map].mod;
+
-  }
+function Atlas(maps) {
-
+    this.maps = maps;
-  //console.log(this.savedMods);
+    this.savedMods = {};
 
     for (var map in this.maps) {
         this.savedMods[this.maps[map].name] = this.maps[map].mod;
-	for ( var map in this.savedMods ) {
+
-  	this.maps[map].mod = this.savedMods[map];
+
-  }
+    //console.log(this.savedMods);
 }
 
 Atlas.prototype.reset = function() {
     for (var map in this.savedMods) {
         this.maps[map].mod = this.savedMods[map];
     }
-for ( var map in mapData ) {
+
-	new Map( map, mapData[map].tier, mapData[map].adjacent, mapData[map].mod );
+
 // END atlas prototype -----------------------------------------
 
 // create map objects
 
-for ( var k in maps ) {
+for (var map in mapData) {
-	var map = maps[k];
+    new Map(map, mapData[map].tier, mapData[map].adjacent, mapData[map].mod);
-
+
-  map.adjacent = map.adjacent.map( function( element ) {
+
-  	if ( ! maps[element] ) {
+
-    	throw new Error( "Could not convert '" + element + "' to object" );
+
 for (var k in maps) {
-  	return maps[element];
+    var map = maps[k];
-  } );
+
     map.adjacent = map.adjacent.map(function(element) {
         if (!maps[element]) {
             throw new Error("Could not convert '" + element + "' to object");
         }
-for ( var k in maps ) {
+        return maps[element];
-	var map = maps[k];
+
-
+
-  map.adjacent.forEach( function( a ) {
+
-  	if ( ! a.isAdjacentTo( map.name ) ) {
+
-    	throw new Error( "1 sided adjacent relation: " + map.name + ", " + a.name );
+
 for (var k in maps) {
-  } )
+    var map = maps[k];
 
     map.adjacent.forEach(function(a) {
         if (!a.isAdjacentTo(map.name)) {
             throw new Error("1 sided adjacent relation: " + map.name + ", " + a.name);
-function applyBlockMod( originMap, currentMap ) {
+        }
-		if ( currentMap.name == "Shaped Primordial Pool" || currentMap.isAdjacentTo( "Shaped Primordial Pool" ) ) {
+    })
-    	return;
+
 
-    if ( currentMap.mod ) {
+
-    	return;
+
 function applyBlockMod(originMap, currentMap) {
     if (currentMap.name == "Shaped Primordial Pool" || currentMap.isAdjacentTo("Shaped Primordial Pool")) {
         return;
     }
-    var mods = originMap.getFilteredModList().filter( function( mod ) {
+    if (currentMap.mod) {
-      return ! goodMods[ mod.name ];
+        return;
-    }).filter( function( mod ) {
+
-      return mod.level == tier.WHITE;
+
     // filter out good mods
-
+
     var mods = originMap.getFilteredModList().filter(function(mod) {
-    mods.sort( function(a, b) {
+        return !goodMods[mod.name];
-      return b.weights.default - a.weights.default;
+    }).filter(function(mod) {
         return mod.level == tier.WHITE;
-
+
 
     // sort by weight, descending
     mods.sort(function(a, b) {
         return b.weights.default-a.weights.default;
     });
 
     currentMap.mod = mods[0];
     console.log("Applied '" + currentMap.mod.name + "' to " + currentMap.name + ".");
-m.adjacent.forEach( function( map ) {
+
-	map.adjacent.forEach( function( map2 ) {
+
-  	applyBlockMod( m, map2 );
+
-  });
+
 var m = maps["Shaped Primordial Pool"];
 
 m.adjacent.forEach(function(map) {
     map.adjacent.forEach(function(map2) {
         applyBlockMod(m, map2);
     });
-m.adjacent.forEach( function( map ) {
+
-	map.adjacent.forEach( function( map2 ) {
+
-  	applyBlockMod( m, map2 );
+
-  });
+
 m = maps["Burial Chambers"];
 
-for ( var m in maps ) {
+m.adjacent.forEach(function(map) {
-	var m = maps[m];
+    map.adjacent.forEach(function(map2) {
-
+        applyBlockMod(m, map2);
-  if ( ! m.isAdjacentTo( "Shaped Primordial Pool" ) ) {
+
-  	continue;
+
-  }
+
-
+for (var m in maps) {
-  // apply to adjacent maps
+    var m = maps[m];
-
+
-  for ( var i = 0; i < m.adjacent.length; i++ ) {
+    if (!m.isAdjacentTo("Shaped Primordial Pool")) {
-  	var c = m.adjacent[i];
+        continue;
-    applyBlockMod( m, c );
+
-  }
+
-
+    // apply to adjacent maps
-  // apply to 2nd degree adjacent maps
+
-
+    for (var i = 0; i < m.adjacent.length; i++) {
-  for ( var i = 0; i < m.adjacent.length; i++ ) {
+        var c = m.adjacent[i];
-  	var proxy = m.adjacent[i];
+        applyBlockMod(m, c);
-
+
-    if ( proxy.name == "Shaped Primordial Pool" ) { continue; }
+
-
+    // apply to 2nd degree adjacent maps
-    for ( var j = 0; j < proxy.adjacent.length; j++ ) {
+
-      var c = proxy.adjacent[j];
+    for (var i = 0; i < m.adjacent.length; i++) {
-      applyBlockMod( m, c );
+        var proxy = m.adjacent[i];
 
-  }
+        if (proxy.name == "Shaped Primordial Pool") {
             continue;
         }
 
-var atl = new Atlas( maps );
+        for (var j = 0; j < proxy.adjacent.length; j++) {
             var c = proxy.adjacent[j];
             applyBlockMod(m, c);
         }
-var swap = function (array, pos1, pos2) {
+
-  var temp = array[pos1];
+
-  array[pos1] = array[pos2];
+
-  array[pos2] = temp;
+
 var atl = new Atlas(maps);
 
-var heapsPermute = function (array, output, n) {
+
-  n = n || array.length; // set n default to array.length
+
-  if (n === 1) {
+var swap = function(array, pos1, pos2) {
-    output(array);
+    var temp = array[pos1];
-  } else {
+    array[pos1] = array[pos2];
-    for (var i = 1; i <= n; i += 1) {
+    array[pos2] = temp;
-      heapsPermute(array, output, n - 1);
+
-      if (n % 2) {
+
-        var j = 1;
+var heapsPermute = function(array, output, n) {
-      } else {
+    n = n || array.length; // set n default to array.length
-        var j = i;
+    if (n === 1) {
-      }
+        output(array);
-      swap(array, j - 1, n - 1); // -1 to account for javascript zero-indexing
+    } else {
         for (var i = 1; i <= n; i += 1) {
-  }
+            heapsPermute(array, output, n - 1);
             if (n % 2) {
                 var j = 1;
             } else {
                 var j = i;
             }
             swap(array, j - 1, n - 1); // -1 to account for javascript zero-indexing
-function result( order ) {
+        }
-	this.order = order;
+
-  this.sum_x = 0;
+
-  this.sum_x2 = 0;
+
-  this.n = 0;
+
 
 // START result prototype --------------------------------------
 
-	return this.sum_x / this.n;
+function result(order) {
     this.order = order;
     this.sum_x = 0;
     this.sum_x2 = 0;
-	var mean = this.mean();
+    this.n = 0;
-	return Math.sqrt( this.sum_x2 / this.n - mean * mean );
+
 
 result.prototype.mean = function() {
-result.prototype.generateSamples = function( n ) {
+    return this.sum_x / this.n;
-	// Apply sextants to maps
+
-  for ( var iter = 0; iter < n; iter++ ) {
+
-    atl.reset();
+
-    var cost = 0;
+    var mean = this.mean();
-
+    return Math.sqrt(this.sum_x2 / this.n - mean * mean);
-    // First, roll any mod on each map in order.
+
-    this.order.forEach( function( m ) {
+
-      if ( ! maps[m].mod ) {
+result.prototype.generateSamples = function(n) {
-        cost += maps[m].roll();
+    // Apply sextants to maps
-      }
+    for (var iter = 0; iter < n; iter++) {
-    } );
+        atl.reset();
-
+        var cost = 0;
-		// Second, finish rolling each map to a good mod, again respecting the order.
+
-    this.order.forEach( function( m ) {
+        // First, roll any mod on each map in order.
-      // While no/bad sextant, keep rolling
+        this.order.forEach(function(m) {
-      while ( ! ( maps[m].mod && goodMods[maps[m].mod.name] ) ) {
+            if (!maps[m].mod) {
-        cost += maps[m].roll();
+                cost += maps[m].roll();
-      }
+            }
-    } );
+        });
-
+
-    this.sum_x += cost;
+        // Second, finish rolling each map to a good mod, again respecting the order.
-    this.sum_x2 += cost * cost;
+        this.order.forEach(function(m) {
-    this.n++;
+            // While no/bad sextant, keep rolling
-  }
+            while (!(maps[m].mod && goodMods[maps[m].mod.name])) {
                 cost += maps[m].roll();
             }
         });
-	return 1.645 * ( this.stdDev() / Math.sqrt( this.n ) );
+
         this.sum_x += cost;
         this.sum_x2 += cost * cost;
         this.n++;
-
+
 }
-	var n = 0;
+
-	for ( var k in a ) {
+
-  	n++;
+    return 1.645 * (this.stdDev() / Math.sqrt(this.n));
-  }
+
-  return n;
+
 // END result prototype ------------------------------------------
 
 function countKeys(a) {
     var n = 0;
     for (var k in a) {
-for ( var map in maps ) {
+        n++;
-	if ( map == "Shaped Primordial Pool" || maps[map].isAdjacentTo( "Shaped Primordial Pool" ) ) {
+
-  	console.log( map + " blocks " + countKeys(maps[map].getBlockedMods()) + " mods");
+    return n;
-  	mapsToRoll.push(map);
+
-  }
+
 var results = [];
 
 var mapsToRoll = [];
-heapsPermute(mapsToRoll, function( order ) {
+for (var map in maps) {
-	/*if ( order[0] !== "Shaped Primordial Pool" ) {
+    if (map == "Shaped Primordial Pool" || maps[map].isAdjacentTo("Shaped Primordial Pool")) {
         console.log(map + " blocks " + countKeys(maps[map].getBlockedMods()) + " mods");
         mapsToRoll.push(map);
     }
-	results.push( new result( order.slice( 0 ) ) );
+
-} );
+
 // create a result entry for every permutation
-while ( true ) {
+heapsPermute(mapsToRoll, function(order) {
-	var results_b = results.filter( function( r ) {
+    /*if ( order[0] !== "Shaped Primordial Pool" ) {
-  	if ( r == results[0] || results[0].n == 0 ) {
+
-    	return true;
+
 
-    return r.mean() - r.confidenceInterval() <= results[0].mean() + results[0].confidenceInterval();
+    results.push(new result(order.slice(0)));
-  } );
+
-
+
-  if ( results_b.length <= 1 || results_b[0].n >= maxIterations ) {
+while (true) {
-  	break;
+    var results_b = results.filter(function(r) {
-  }
+        if (r == results[0] || results[0].n == 0) {
-
+            return true;
-  console.log( results[0].n + " iterations (" + results_b.length + " remaining permutations)" );
+        }
-
+        return r.mean() - r.confidenceInterval() <= results[0].mean() + results[0].confidenceInterval();
-  var iterTarget = results[0].n + 5000 / Math.sqrt( results_b.length );
+
-
+
-  results_b.forEach( function( r ) {
+    if (results_b.length <= 1 || results_b[0].n >= maxIterations) {
-  	r.generateSamples( iterTarget - r.n );
+
-  } );
+
-
+
-  results.sort( function( a, b ) {
+    console.log(results[0].n + " iterations (" + results_b.length + " remaining permutations)");
-  	return a.mean() - b.mean();
+
-  } );
+    var iterTarget = results[0].n + 5000 / Math.sqrt(results_b.length);
 
     results_b.forEach(function(r) {
-console.log( "Results (up to " + maxIterations + " iterations):" );
+        r.generateSamples(iterTarget - r.n);
     });
-for ( var i = 0; i < results.length; i++ ) {
+
-  var str = "" + results[i].mean().toFixed(3) + " ± " + results[i].confidenceInterval().toFixed(3) + "c";
+    results.sort(function(a, b) {
         return a.mean() - b.mean();
-  for ( var j = 0; j < results[i].order.length; j++ ) {
+
-    if ( j > 0 ) { str += "," };
+
-    str += " " + results[i].order[j];
+
-  }
+console.log("Results (up to " + maxIterations + " iterations):");
 
-  console.log(str);
+for (var i = 0; i < results.length; i++) {
     var str = "" + results[i].mean().toFixed(3) + " ± " + results[i].confidenceInterval().toFixed(3) + "c";
 
     for (var j = 0; j < results[i].order.length; j++) {
         if (j > 0) {
             str += ","
         };
         str += " " + results[i].order[j];
     }
 
     console.log(str);
 }