--- libmalloc/libmalloc-715.140.5/src/nano_malloc_common.c
+++ libmalloc/libmalloc-374.120.1/src/nano_malloc_common.c
@@ -43,29 +43,29 @@
 
 // The maximum number of per-CPU allocation regions to use for Nano.
 unsigned int nano_common_max_magazines;
-bool nano_common_max_magazines_is_ncpu = true;
-
-unsigned int nano_max_region = NANOV2_MAX_REGION_NUMBER;
+boolean_t nano_common_max_magazines_is_ncpu = true;
 
 // Boot argument for nano_common_max_magazines
 static const char nano_max_magazines_boot_arg[] = "malloc_nano_max_magazines";
 
-
 #pragma mark -
 #pragma mark Initialization
 
-nano_version_t
-_nano_common_init_pick_mode(const char *envp[], const char *apple[], const char *bootargs, bool space_efficient_enabled)
-{
-	const char *p = NULL;
-	const char *flag = NULL;
-	nano_version_t ret = NANO_NONE;
-
+// Shared initialization code. Determines which version of Nano should be used,
+// if any, and sets _malloc_engaged_nano. The Nano version is determined as
+// follows:
+// 1. If the nanov2_mode boot arg has value "forced", Nano V2 is used
+//		unconditionally in every process
+// 2. If the nanov2_mode boot arg has value "enabled", Nano V2 is used if
+//		the process wants to use Nano
+void
+nano_common_init(const char *envp[], const char *apple[], const char *bootargs)
+{
 	// Use the nanov2_mode boot argument and MallocNanoZone to determine
 	// whether to use nano
 	nanov2_mode_t nanov2_mode = NANOV2_DEFAULT_MODE;
 
-	p = malloc_common_value_for_key(bootargs, mode_boot_arg);
+	const char *p = malloc_common_value_for_key(bootargs, mode_boot_arg);
 	if (p) {
 		if (!strncmp(p, enabled_mode, sizeof(enabled_mode) - 1)) {
 			nanov2_mode = NANO_ENABLED;
@@ -77,79 +77,34 @@
 	}
 
 	if (nanov2_mode == NANO_FORCED) {
-		ret = NANO_V2;
+		_malloc_engaged_nano = NANO_V2;
 	} else {
+		const char *flag = NULL;
 		if (nanov2_mode == NANO_CONDITIONAL) {
 			// If conditional mode is selected, ignore the apple[] array and
 			// make the decision based of space efficient mode.
-			ret = space_efficient_enabled ? NANO_NONE : NANO_V2;
+			_malloc_engaged_nano = malloc_space_efficient_enabled ? NANO_NONE : NANO_V2;
 		} else {
 			flag = _simple_getenv(apple, "MallocNanoZone");
 			if (flag && flag[0] == '1') {
-				ret = NANO_V2;
+				_malloc_engaged_nano = NANO_V2;
 			}
 		}
 		/* Explicit overrides from the environment */
 		flag = _simple_getenv(envp, "MallocNanoZone");
 		if (flag) {
 			if (flag[0] == '1') {
-				ret = NANO_V2;
+				_malloc_engaged_nano = NANO_V2;
 			} else if (flag[0] == '0') {
-				ret = NANO_NONE;
+				_malloc_engaged_nano = NANO_NONE;
 			} else if (flag[0] == 'V' || flag[0] == 'v') {
 				if (flag[1] == '1' || flag[1] == '2') {
-					ret = NANO_V2;
+					_malloc_engaged_nano = NANO_V2;
 				}
 			}
 		}
 	}
 
-	return ret;
-}
-
-// Shared initialization code. Determines which version of Nano should be used,
-// if any, and sets _malloc_engaged_nano. The Nano version is determined as
-// follows:
-// 1. If the nanov2_mode boot arg has value "forced", Nano V2 is used
-//		unconditionally in every process
-// 2. If the nanov2_mode boot arg has value "enabled", Nano V2 is used if
-//		the process wants to use Nano
-void
-nano_common_init(const char *envp[], const char *apple[], const char *bootargs)
-{
-	_malloc_engaged_nano = _nano_common_init_pick_mode(envp, apple, bootargs, malloc_space_efficient_enabled);
-
-#if NANOV2_MULTIPLE_REGIONS
-	// Override max region number from environment
-	const char *p = malloc_common_value_for_key(bootargs, "malloc_nano_max_region");
-	if (p) {
-		long value = strtol(p, NULL, 10);
-		if (value) {
-			if (value > NANOV2_MAX_REGION_NUMBER) {
-				nano_max_region = NANOV2_MAX_REGION_NUMBER;
-				malloc_report(ASL_LEVEL_INFO, "Capping 'malloc_nano_max_region' to %d\n", nano_max_region);
-			} else if (value >= 0) {
-				nano_max_region = (unsigned int)value;
-			} else {
-				malloc_report(ASL_LEVEL_ERR, "Received invalid value for 'malloc_nano_max_region': %d\n", (int)value);
-			}
-		}
-	}
-	const char *flag = _simple_getenv(envp, "MallocNanoMaxRegion");
-	if (flag) {
-		long value = strtol(flag, NULL, 10);
-		if (value) {
-			if (value > NANOV2_MAX_REGION_NUMBER) {
-				nano_max_region = NANOV2_MAX_REGION_NUMBER;
-				malloc_report(ASL_LEVEL_INFO, "Capping 'MallocNanoMaxRegion' to %d\n", nano_max_region);
-			} else if (value >= 0) {
-				nano_max_region = (unsigned int)value;
-			} else {
-				malloc_report(ASL_LEVEL_ERR, "Received invalid value for 'MallocNanoMaxRegion': %d\n", (int)value);
-			}
-		}
-	}
-#endif // NANOV2_MULTIPLE_REGIONS
 	if (_malloc_engaged_nano) {
 		// The maximum number of nano magazines can be set either via a
 		// boot argument or from the environment. Get the boot argument value
@@ -272,53 +227,25 @@
 	return (void *)addr;
 }
 
-static boolean_t
-_nano_common_map_vm_space(mach_vm_address_t base, mach_vm_size_t size, 
-		vm_prot_t cur_protection)
-{
-	mach_vm_address_t vm_addr = base;
-
-	kern_return_t kr = mach_vm_map(mach_task_self(), &vm_addr, size, 0,
-		VM_MAKE_TAG(VM_MEMORY_MALLOC_NANO), MEMORY_OBJECT_NULL, 0, FALSE,
-		cur_protection, VM_PROT_ALL, VM_INHERIT_DEFAULT);
-
-	if (kr != KERN_SUCCESS) {
-		return FALSE;
-	} else if (vm_addr != base) {
-		// allocated somewhere else
-		mach_vm_deallocate(mach_task_self(), vm_addr, size);
-		return FALSE;
-	}
-	return TRUE;
-}
-
 // Allocates virtual address from a given address for a given size. Succeeds
 // (and returns TRUE) only if we get exactly the range of addresses that we
 // asked for.
-bool
+boolean_t
 nano_common_allocate_vm_space(mach_vm_address_t base, mach_vm_size_t size)
 {
-	return _nano_common_map_vm_space(base, size, VM_PROT_DEFAULT);
-}
-
-// Reserve virtual address range by allocating without perimissions
-bool
-nano_common_reserve_vm_space(mach_vm_address_t base, mach_vm_size_t size)
-{
-	return _nano_common_map_vm_space(base, size, VM_PROT_NONE);
-}
-
-// Set protection to default for address range. Return true on success.
-bool
-nano_common_unprotect_vm_space(mach_vm_address_t base, mach_vm_size_t size)
-{
-	kern_return_t kr = mach_vm_protect(mach_task_self(), base,
-			size, false, VM_PROT_DEFAULT);
-	if (kr != KERN_SUCCESS) {
-		malloc_report(ASL_LEVEL_ERR, "mach_vm_protect ret: %d\n", kr);
-		return false;
-	}
-	return true;
+	mach_vm_address_t vm_addr = base;
+	kern_return_t kr = mach_vm_map(mach_task_self(), &vm_addr, size, 0,
+		VM_MAKE_TAG(VM_MEMORY_MALLOC_NANO), MEMORY_OBJECT_NULL, 0, FALSE,
+		VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);
+	
+	if (kr != KERN_SUCCESS || vm_addr != base) {
+		// Failed or we got allocated somewhere else.
+		if (!kr) {
+			mach_vm_deallocate(mach_task_self(), vm_addr, size);
+		}
+		return FALSE;
+	}
+	return TRUE;
 }
 
 void