main.cpp

#define UNICODE
#include <iostream>
#include "fileformat.pb.h"
#include "osmformat.pb.h"
#include "OBF.pb.h"
#include "vector_tile.pb.h"
#include "osmand_region_info.pb.h"
#include "osmand_index.pb.h"
#include <fstream>
#include <string>
#include "sqlite3.h"
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <iomanip>
#include <unordered_set>
#if defined(_WIN32)
	#include <windows.h>
	#include <process.h>
	#include <commctrl.h>
#endif
#include <wchar.h>
#include <codecvt>
#include <filesystem>
#include <unordered_map>
#include <memory>
#include <string_view>
#include <filesystem>
#include <array>
#include <atomic>
#include <iomanip>
#include <sstream>
#include <cmath>
#if defined(__linux__)
	#include <unistd.h>
#endif
#include <thread>
#include <chrono>

using namespace std;
void writeOBFVarint32or64BE(google::protobuf::io::CodedOutputStream &i, uint64_t n);
uint64_t copyRawFileIntoCodedOutputStream(google::protobuf::io::CodedOutputStream &cos, string filename, int64_t size);
void copyRawInputStreamIntoCodedOutputStream(google::protobuf::io::CodedOutputStream &cos, istream *inputFile, int64_t size);
static inline int64_t getFileSize(string name);
std::wstring utf8_to_wstring(const std::string& str);
std::string wstring_to_utf8(const std::wstring& str);
uint64_t writeMapIndex(string name);
void writeOsmAndStructure_mapIndex_rules(google::protobuf::io::CodedOutputStream &cos);
void writeMapEncodingRule(string tag, string value, uint32_t minZoom);
static inline uint64_t GetSystemTimeAsUnixTime();
static inline int32_t latitudeToInt32(double latitude, uint32_t zoom, bool fullAccuracy = false);
static inline int32_t longitudeToInt32(double longitude, uint32_t zoom, bool fullAccuracy = false);
void writeOsmAndStructure_mapIndex_detailed_level_1x1(unsigned char *coordinatesByteArrayPtrWithinThread, unsigned char *typesByteArrayPtrWithinThread, unsigned char *additionalTypesByteArrayPtrWithinThread, unsigned char *stringNamesByteArrayPtrWithinThread);
void writeOsmAndStructure_mapIndex_detailed_level_single_power_of_2_split(int pow2, bool mediumZoom);
void writeOsmAndStructure_mapIndex_detailed_level_4_4_pow2_split(int pow2, bool mediumZoom);
void writeOsmAndStructure_mapIndex_detailed_level_4_4_4_pow2_split(int pow2, bool mediumZoom);
double int32ToLatitude(uint64_t in, uint32_t zoom);
double int32ToLongitude(uint64_t in, uint32_t zoom);
uint32_t getVarintRequiredBytes(uint64_t i);
void printHelp();
static inline int min3(int64_t a, int64_t b, int64_t c);
void writeOsmAndStructure_mapIndex_levels_block_SingleSplitThreadWorker(void *param);
#if defined(_WIN32)
	LRESULT CALLBACK WndProc(HWND hwndMainWin, UINT msg, WPARAM wParam, LPARAM lParam);
	bool CALLBACK SetFont(HWND child, LPARAM font);
#endif
void VWSimplify(vector<uint64_t> *nodeIDVector, vector<uint64_t> *latVector, vector<uint64_t> *lonVector, uint64_t minAreaX2);
string humanReadableTimeFromSeconds(unsigned int seconds);
void createOBFFile(void *param);
void calculateTotalRectanglesForGUI();

#define FILE_COPY_BUFFER_SIZE (32 * 1048576) //This needs the parentheses or it will evaluate the numbers separately
#define PI 3.1415926535
unsigned char *fileCopyBuffer = nullptr;
#define PROTOBUF_SERIALIZE_TEMP_BUFFER_SIZE 1048576
//Multiples of 32 so this is 1024
#define NODE_BLOCK_OVERLAP 32
#define IDEAL_BLOCK_MAX_SIZE 750000
static const char* GET_KEYS_AND_VALUES_SORTED_QUERY = "SELECT key, value, (key in (%HUMAN_READABLE_WHITELIST%) or key like 'addr:%') as human_readable, COUNT(*) p, COUNT(*) OVER () AS total_rows FROM (SELECT key, value FROM node_tags WHERE %MACHINE_READABLE_BLACKLIST% UNION ALL SELECT key, value FROM way_tags WHERE %MACHINE_READABLE_BLACKLIST%) q1 GROUP BY concat(key, \"=\", value) ORDER BY p DESC;";
static const char* GET_WAY_AND_NODE_KEYS_SORTED_QUERY_BLACKLIST = "select key, count(key) as p, way from (select q1.*, 1 as way from way_tags q1 union all select q2.*, 0 as way from node_tags q2) where key not like 'tiger%' and key not like 'source%' and key not like 'attribution%' and key not like 'nhd%' and key not like 'power%' and key not like 'created_by%' and key not like 'seamark%' and key not like 'gnis%' and key not like 'fid%' and key not like 'fixme%' and key not like 'roof%' group by key order by p desc;";
static const char* QUERY_GET_UNIQUE_WAY_AND_NODE_TAG_VALUES_BLACKLIST = "select value, count(*) as p, way, count(*) over () as total from (select q1.value, 1 as way from way_tags q1 inner join way_nodes q4 on q4.way_id=q1.way_id and q4.node_order=1 inner join rtree_node q5 on q5.node_id=q4.node_id and q5.max_lat >= :bottom and q5.min_lat <= :top and q5.max_lon >= :left and q5.min_lon <= :right where q1.key not like 'tiger%' and q1.key not like 'source%' and q1.key not like 'attribution%' and q1.key not like 'nhd%' and q1.key not like 'power%' and q1.key not like 'created_by%' and q1.key not like 'seamark%' and q1.key not like 'gnis%' and q1.key not like 'fid%' and q1.key not like 'fixme%' and q1.key not like 'roof%' union all select q2.value, 0 as way from node_tags q2 inner join rtree_node q3 on q3.node_id=q2.node_id and q3.max_lat >= :bottom and q3.min_lat <= :top and q3.max_lon >= :left and q3.min_lon <= :right where q2.key not like 'tiger%' and q2.key not like 'source%' and q2.key not like 'attribution%' and q2.key not like 'nhd%' and q2.key not like 'power%' and q2.key not like 'created_by%' and q2.key not like 'seamark%' and q2.key not like 'gnis%' and q2.key not like 'fid%' and q2.key not like 'fixme%' and q2.key not like 'roof%') group by value order by p desc;";
static const char* QUERY_GET_MEDIAN_UNIQUE_ID = "select median(id) from (select q1.way_id as id from way_nodes q1 inner join rtree_node q2 on q2.node_id=q1.node_id where q1.node_order=1 and (q2.max_lat >= :bottom and q2.min_lat <= :top) and (q2.max_lon >= :left and q2.min_lon <= :right) union all select node_id as id from rtree_node q4 where (q4.max_lat >= :bottom and q4.min_lat <= :top) and (q4.max_lon >= :left and q4.min_lon <= :right));";
static const char* QUERY_GET_UNIQUE_WAY_AND_NODE_TAG_VALUES_BLACKLIST_MEDIUM_ZOOM = "select value, count(value) as p, way, count(*) over () from (select q1.*, 1 as way from way_tags q1 inner join way_nodes q4 on q4.node_order=1 and q4.way_id=q1.way_id inner join rtree_node q5 on q5.node_id=q4.node_id where (q5.max_lat >= :bottom and q5.min_lat <= :top) and (q5.max_lon >= :left and q5.min_lon <= :right) union all select q2.*, 0 as way from node_tags q2 inner join rtree_node q3 on q3.node_id=q2.node_id where (q3.max_lat >= :bottom and q3.min_lat <= :top) and (q3.max_lon >= :left and q3.min_lon <= :right)) where way_id in (select q1.way_id from (select q1.way_id from way_nodes q1 inner join rtree_node q2 on q2.node_id=q1.node_id inner join way_tags q3 on q3.way_id=q1.way_id where q1.node_order=1 and (q2.max_lat >= :bottom and q2.min_lat <= :top) and (q2.max_lon >= :left and q2.min_lon <= :right) and ((key = 'highway' and value in ('motorway', 'motorway_link', 'motorway_junction', 'primary', 'primary_link', 'secondary', 'secondary_link', 'tertiary', 'tertiary_link', 'trunk', 'trunk_link')) or (key in ('lanes', 'lanes:forward', 'lanes:backward', 'hgv', 'maxspeed', 'oneway', 'destination', 'motorway_link')))) q1) and ((key = 'highway' and value in ('motorway', 'motorway_link', 'motorway_junction', 'primary', 'primary_link', 'secondary', 'secondary_link', 'tertiary', 'tertiary_link', 'trunk', 'trunk_link')) or (key in ('lanes', 'lanes:forward', 'lanes:backward', 'hgv', 'maxspeed', 'oneway', 'name', 'ref', 'destination', 'motorway_link'))) group by value order by p desc;";
static const char* QUERY_GET_WAY_NODES = "select q1.*, lag(q1.lat, 1) over () as prevLat, lag(q1.lon, 1) over () as prevLon, row_number() over (partition by q1.way_id order by way_id asc, node_order asc) as index_within_way from ( select way_id, q1.node_id, node_order, lat, lon from way_nodes q1 left join nodes q2 on q1.node_id=q2.node_id order by way_id asc, node_order asc) q1 WHERE lat is not null AND lon is not null /*and way_id=1527655305*/;";
static const char* QUERY_GET_WAY_TAGS = "select q1.key, q1.value, (case when q1.key in (%HIGH_PRIORITY_WHITELIST%) then 0 when key in (%HUMAN_READABLE_WHITELIST%) then 2 else 1 end) as tagType from way_tags q1 where %MACHINE_READABLE_BLACKLIST% %WAY_ID% group by key, value order by tagType asc, key asc, value asc;";
static const char* QUERY_GET_NODE_TAGS_MACHINE_READABLE = "select concat(q1.key, '=', q1.value) as tag, (case when q1.key in (%HIGH_PRIORITY_WHITELIST%) then 1 else 0 end) as high_priority from node_tags q1 where %KEY_BLACKLIST% and node_id=%NODE_ID% group by key, value order by high_priority desc, key asc, value asc";
static const string TAG_KEYS_HIGH_PRIORITY_WHITELIST = "'highway', 'service', 'building', 'amenity', 'barrier'";
static const string TAG_KEYS_BLACKLIST = "key not like 'tiger%' AND key NOT LIKE 'source%' AND key NOT LIKE 'attribution%' AND key NOT LIKE 'nhd%' AND key NOT LIKE 'power%' AND key NOT LIKE 'created_by%' AND key NOT LIKE 'seamark%' AND key NOT LIKE 'gnis%' AND key NOT LIKE 'fid%' AND key NOT LIKE 'fixme%' AND key NOT LIKE 'roof%' AND key NOT LIKE 'ref' AND key NOT LIKE 'ref:%' AND key NOT LIKE 'website%' AND key NOT LIKE 'wikipedia%' AND key NOT LIKE 'wikimedia_commons%' AND key NOT LIKE 'ele%' AND key NOT LIKE 'description%' AND key NOT LIKE 'length%' AND key NOT LIKE 'architect%' AND key NOT LIKE '%colour%' AND key NOT LIKE 'operator:wikidata%' AND key NOT LIKE 'height%' AND key NOT LIKE 'image%' AND key NOT LIKE 'mapillary%' AND key NOT LIKE 'mascot%' AND key NOT LIKE 'note%' AND key NOT LIKE 'artist_name%' AND key NOT LIKE 'check_date%' AND key NOT LIKE 'reg_name%' AND key NOT LIKE 'short_name%' AND key NOT LIKE 'distance%' AND key NOT LIKE 'direction%' AND key NOT LIKE 'heritage%'";
static const string TAG_KEYS_MACHINE_READABLE_BLACKLIST = "key not like 'tiger%' AND key NOT LIKE 'source%' AND key NOT LIKE 'attribution%' AND key NOT LIKE 'nhd%' AND key NOT LIKE 'power%' AND key NOT LIKE 'created_by%' AND key NOT LIKE 'seamark%' AND key NOT LIKE 'gnis%' AND key NOT LIKE 'fid%' AND key NOT LIKE 'fixme%' AND key NOT LIKE 'roof%' AND key NOT LIKE 'addr:%' AND key NOT LIKE 'ref' AND key NOT LIKE 'ref:%' AND key NOT LIKE 'website%' AND key NOT LIKE 'wikipedia%' AND key NOT LIKE 'wikimedia_commons%' AND key NOT LIKE 'ele%' AND key NOT LIKE 'description%' AND key NOT LIKE 'length%' AND key NOT LIKE 'architect%' AND key NOT LIKE '%colour%' AND key NOT LIKE 'operator:wikidata%' AND key NOT LIKE 'height%' AND key NOT LIKE 'image%' AND key NOT LIKE 'mapillary%' AND key NOT LIKE 'mascot%' AND key NOT LIKE 'note%' AND key NOT LIKE 'artist_name%' AND key NOT LIKE 'check_date%' AND key NOT LIKE 'reg_name%' AND key NOT LIKE 'short_name%' AND key NOT LIKE 'distance%' AND key NOT LIKE 'direction%' AND key NOT LIKE 'heritage%'";
static const string TAG_KEYS_HUMAN_READABLE_WHITELIST = "'name', 'name_1', 'name_2', 'old_name', 'official_name', 'addr:', 'addr:housenumber', 'addr:street', 'addr:city', 'addr:state', 'addr:postcode', 'ref', 'website', 'wikipedia', 'wikidata', 'wikimedia_commons', 'opening_hours', 'brand', 'alt_name', 'start_date', 'contact', 'phone', 'fax', 'description', 'email', 'addr:country', 'operator'";
static const string KEY_BLACKLIST = "key NOT LIKE 'tiger%' AND key NOT LIKE 'source%' AND key NOT LIKE 'attribution%' AND key NOT LIKE 'nhd%' AND key NOT LIKE 'power%' AND key NOT LIKE 'created_by%' AND key NOT LIKE 'seamark%' AND key NOT LIKE 'gnis%' AND key NOT LIKE 'fid%' AND key NOT LIKE 'fixme%' AND key NOT LIKE 'roof%' AND key NOT LIKE 'ncos%' AND key NOT LIKE 'was:%' AND key NOT LIKE 'old_name%'";
static unordered_map<string, uint32_t> keyMap;

static inline uint32_t getSInt32FromInt32(int32_t i) {
    return (static_cast<uint32_t>(i) << 1) ^ static_cast<uint32_t>(i >> 31);
}

unsigned int getClosestNextLowerPowerOf2(unsigned int i) {
	unsigned int j = 0;
	unsigned int retVal = 0;
	while ((2 << retVal) <= i) retVal++;
	return retVal;
}

class BoundingRectangle {
public:
	double left = 0;
	double bottom = 0;
	double right = 0;
	double top = 0;
	double width = 0;
	double height = 0;
	uint64_t leftInt32 = 0;
	uint64_t rightInt32 = 0;
	uint64_t topInt32 = 0;
	uint64_t bottomInt32 = 0;
	uint64_t widthInt32 = 0;
	uint64_t heightInt32 = 0;
	uint64_t MapDataBoxBytesSizeWithoutTagAndFixed32Size = 0;

	void calculateDoubleValuesFromInt32() {
		this->left = int32ToLongitude(this->leftInt32, 21);
		this->right = int32ToLongitude(this->rightInt32, 21);
		this->top = int32ToLatitude(this->topInt32, 21);
		this->bottom = int32ToLatitude(this->bottomInt32, 21);
		this->width = this->right - this->left;
		this->height = this->top - this->bottom;
		this->widthInt32 = this->rightInt32 - this->leftInt32;
		this->heightInt32 = this->bottomInt32 - this->topInt32;
	}

	void calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(BoundingRectangle *outerRectangle) {
		MapDataBoxBytesSizeWithoutTagAndFixed32Size =
			1 + getVarintRequiredBytes(getSInt32FromInt32(this->leftInt32 - outerRectangle->leftInt32)) +
			1 + getVarintRequiredBytes(getSInt32FromInt32(this->rightInt32 - outerRectangle->rightInt32)) +
			1 + getVarintRequiredBytes(getSInt32FromInt32(this->topInt32 - outerRectangle->topInt32)) +
			1 + getVarintRequiredBytes(getSInt32FromInt32(this->bottomInt32 - outerRectangle->bottomInt32)) +
			1 + 4;
	}

	void calculateInt32ValuesFromDouble() {
		this->leftInt32 = longitudeToInt32(this->left, 21) & 0xffffffe0;
		this->rightInt32 = longitudeToInt32(this->right, 21) & 0xffffffe0;
		this->topInt32 = latitudeToInt32(this->top, 21) & 0xffffffe0;
		this->bottomInt32 = latitudeToInt32(this->bottom, 21) & 0xffffffe0;
		this->width = this->right - this->left;
		this->height = this->top - this->bottom;
		this->widthInt32 = this->rightInt32 - this->leftInt32;
		this->heightInt32 = this->bottomInt32 - this->topInt32;
	}

	void expandByPercent(double percent) {
		uint64_t widthExpandAmountInt32 = (this->widthInt32 * percent) / 100.0;
		uint64_t heightExpandAmountInt32 = (this->heightInt32 * percent) / 100.0;
		this->leftInt32 -= widthExpandAmountInt32;
		this->leftInt32 &= 0xffffffe0;
		this->rightInt32 += widthExpandAmountInt32;
		this->rightInt32 &= 0xffffffe0;
		this->topInt32 -= heightExpandAmountInt32;
		this->topInt32 &= 0xffffffe0;
		this->bottomInt32 += heightExpandAmountInt32;
		this->bottomInt32 &= 0xffffffe0;
		this->calculateDoubleValuesFromInt32();
	}
	
	void expandByAbsoluteValue(int64_t n) {
		this->leftInt32 -= n;
		if ((this->leftInt32 & 0x1f) >= 16) this->leftInt32 -= 32;
		this->leftInt32 &= 0xffffffe0;
		this->rightInt32 += n;
		if ((this->rightInt32 & 0x1f) >= 16) this->rightInt32 -= 32;
		this->rightInt32 &= 0xffffffe0;
		this->topInt32 -= n;
		if ((this->topInt32 & 0x1f) >= 16) this->topInt32 += 32;
		this->topInt32 &= 0xffffffe0;
		this->bottomInt32 += n;
		if ((this->bottomInt32 & 0x1f) >= 16) this->bottomInt32 += 32;
		this->bottomInt32 &= 0xffffffe0;
		this->calculateDoubleValuesFromInt32();
	}
};
static BoundingRectangle overallBoundingRectangle;

struct MapDataBlockThreadInfo {
	string tempFilename;
	BoundingRectangle *rectangles;
	int rectanglesCount;
	int rectanglesStartIdx;
	int stride;
	sqlite3 *dbConnection;
	sqlite3_stmt *stmt;
	int threadID;
	unsigned char *coordinatesByteArrayPtrWithinThread;
	unsigned char *typesByteArrayPtrWithinThread;
	unsigned char *additionalTypesByteArrayPtrWithinThread;
	unsigned char *stringNamesByteArrayPtrWithinThread;
	bool mediumZoom;
	uint64_t *mapDataBlockSizes;
	MapDataBlockThreadInfo():tempFilename(""),rectangles(nullptr),rectanglesCount(0),rectanglesStartIdx(0),stride(0),dbConnection(nullptr),stmt(nullptr),threadID(0),coordinatesByteArrayPtrWithinThread(nullptr),typesByteArrayPtrWithinThread(nullptr),additionalTypesByteArrayPtrWithinThread(nullptr),stringNamesByteArrayPtrWithinThread(nullptr),mediumZoom(false),mapDataBlockSizes(nullptr){}
};

void writeOsmAndStructure_mapIndex_levels_block(string tempFilename, BoundingRectangle *rectangle, unsigned int blockIdx, sqlite3 *dbConnection, sqlite3_stmt *stmt, sqlite3_stmt *wayNodeStmt, sqlite3_stmt *wayTagStmt, int threadID, unsigned char *coordinatesByteArrayPtrWithinThread, unsigned char *typesByteArrayPtrWithinThread, unsigned char *additionalTypesByteArrayPtrWithinThread, unsigned char *stringNamesByteArrayPtrWithinThread, bool mediumZoom);

template <typename T>
T swap_endian(T u) {
	static_assert(sizeof(char) == 1, "Bytes must be 8 bits");
	union {
		T u;
		unsigned char s[sizeof(T)];
	} source, dest;

	source.u = u;
	for (size_t i = 0; i < sizeof(T); ++i) {
		dest.s[i] = source.s[sizeof(T) - i - 1];
	}
	return dest.u;
}

static uint64_t currentDiskUsage = 0;
static sqlite3 *db;
static sqlite3_stmt *res;
static string databaseFilename = "";
static bool shouldKeepTempFiles = false;
static int forcedSplitPowerOf2 = -1;
static int forceSplitMode = -1; //-1 = automatic, 0 = single, 1 = 2-level quadtree, 2 = 3-level quadtree
static bool verbose = false;
uint32_t screenWidth, screenHeight;
//static unsigned int threads = 4;
static unsigned int progressBitmapWidth, progressBitmapHeight, progressTotalRectangles;
atomic<unsigned int> progressCompletedRectangles = {0};
static unsigned char *progressBitmapPtr = nullptr;
static bool shouldShowGUI = true;
static unsigned int guiSelectedQuadtreeSplit = 0;
static unsigned int guiSelectedSplitWithinQuadtree = 0;
uint32_t pid = 0;
uint64_t sqliteCacheSizeMiBPerThread = 64;
uint64_t sqliteMMAPSizeMiBPerThread = 64;

#define ID_STARTBTN 1
#define ID_INPUT_FILENAME_FIELD 2
#define ID_OUTPUT_FILENAME_FIELD 3
#define WM_USER_REDRAW (WM_USER + 1)
#define ID_QUADTREE_COMBOBOX 4
#define ID_SPLIT_COMBOBOX 5
#define ID_BROWSE_INPUT_FILE 6
#define ID_BROWSE_OUTPUT_FILE 7

#if defined(_WIN32)
	static HWND hwndMainWin;
	static HWND hwndStartBtn;
	static HWND hwndInputFilenameLabel;
	static HWND hwndOutputFilenameLabel;
	static HWND hwndInputFilenameField;
	static HWND hwndOutputFilenameField;
	static HWND hwndSplitLabel;
	static HWND hwndQuadtreeCombobox;
	static HWND hwndSplitCombobox;
	static HWND hwndRectangleCountLabel;
	static HWND hwndDetailedVectorMapProgressLabel;
	static HWND hwndDetailedVectorMapProgressBar;
	static HWND hwndProgressPercentLabel;
	static HWND hwndInputFilenameBrowseButton;
	static HWND hwndOutputFilenameBrowseButton;
#endif

struct SQLite3StatementDeleter {
	void operator()(sqlite3_stmt* stmt) const {
		if (stmt) {
			sqlite3_finalize(stmt);
			stmt = nullptr;
		}
	}
};

string inputFilename = "";
string outputFilename = "";
bool foundInputFilenameArgument = false;
bool foundOutputFilenameArgument = false;

int main(int argc, char** argv) {
	cout << "OsmAndMapCreator++ v0.1.12" << endl;
	#if defined(_WIN32)
		pid = GetCurrentProcessId();
	#elif defined(__linux__)
		pid = getpid();
	#endif

	//If there is only 1 argument that is not the help option then assume that it's the input filename
	if (argc == 2) {
		filesystem::path inputFilePathTmp = string(argv[1]);
		if (filesystem::exists(inputFilePathTmp)) {
			inputFilename = string(argv[1]);
			filesystem::path outputFilenamePath = inputFilename;
			outputFilenamePath = outputFilenamePath.parent_path() / outputFilenamePath.stem();
			outputFilename = outputFilenamePath.string() + ".obf";
		} else {
			string_view arg_view(argv[1]);
			printHelp();
			#if defined(__linux__)
				cout << endl;
			#endif
			return 0;
		}
	} else if (argc > 2) {
		for (int i = 1; i < argc; i++) {
			string_view arg_view(argv[i]);
			if ((arg_view == "-i"sv || arg_view == "-input"sv || arg_view == "--input"sv || arg_view == "/i"sv) && i < (argc - 1) /* Don't try to read past the end of the arguments */) {
				inputFilename = string(argv[i + 1]);
				foundInputFilenameArgument = true;
				filesystem::path outputFilenamePath = inputFilename;
				outputFilenamePath = outputFilenamePath.parent_path() / outputFilenamePath.stem();
				outputFilename = outputFilenamePath.string() + ".obf";
			}
		
			if ((arg_view == "-o"sv || arg_view == "-output"sv || arg_view == "--output"sv || arg_view == "/o"sv) && i < (argc - 1)) {
				foundOutputFilenameArgument = true;
				outputFilename = string(argv[i + 1]);
			}

			if ((arg_view == "-keep-temp-files"sv || arg_view == "--keep-temp-files"sv || arg_view == "-keep_temp_files"sv || arg_view == "--keep_temp_files"sv || arg_view == "/keep-temp-files" || arg_view == "/keep_temp_files")) {
				shouldKeepTempFiles = true;
			}
			
			//if ((arg_view == "-force-single-split"sv || arg_view == "--force-single-split"sv || arg_view == "/force-single-split"sv) && i < (argc - 1)) {
				//if (forceSplitMode < 0 /* single split*/) {
					//forceSplitMode = 0;
					//forcedSplitPowerOf2 = atoi(argv[i + 1]); //A forced quadtree split takes precedence
				//}
			//}
			
			if ((arg_view == "-force-quadtree2-split"sv || arg_view == "--force-quadtree2-split"sv || arg_view == "/force-quadtree2-split"sv) && i < (argc - 1)) {
				if (forceSplitMode < 1 /* 2-level quadtree */) {
					forceSplitMode = 1;
					forcedSplitPowerOf2 = atoi(argv[i + 1]);
				}
			}
			
			if ((arg_view == "-force-quadtree3-split"sv || arg_view == "--force-quadtree3-split"sv || arg_view == "/force-quadtree3-split"sv) && i < (argc - 1)) {
				if (forceSplitMode < 2 /* 3-level quadtree */) {
					forceSplitMode = 2;
					forcedSplitPowerOf2 = atoi(argv[i + 1]);
				}
			}
			
			if ((arg_view == "-nogui"sv || arg_view == "--nogui"sv || arg_view == "/nogui"sv || arg_view == "-no-gui"sv || arg_view == "--no-gui"sv || arg_view == "/no-gui"sv)) {
				shouldShowGUI = false;
			}
			
			if ((arg_view == "-verbose"sv || arg_view == "--verbose"sv || arg_view == "/verbose"sv)) {
				verbose = true;
			}

			if ((arg_view == "-cache-size"sv || arg_view == "--cache-size"sv || arg_view == "/cache-size"sv) && i < (argc - 1)) {
				sqliteCacheSizeMiBPerThread = atoi(argv[i + 1]);
				if (sqliteCacheSizeMiBPerThread == 0) sqliteCacheSizeMiBPerThread = 64;
			}

			if ((arg_view == "-mmap-size"sv || arg_view == "--mmap-size"sv || arg_view == "/mmap-size"sv) && i < (argc - 1)) {
				sqliteMMAPSizeMiBPerThread = atoi(argv[i + 1]);
				if (sqliteMMAPSizeMiBPerThread == 0) sqliteMMAPSizeMiBPerThread = 64;
			}
		}
	}
	
	if (shouldShowGUI) {
		#if defined(_WIN32)
			INITCOMMONCONTROLSEX iccx;
			iccx.dwSize = sizeof(INITCOMMONCONTROLSEX);
			iccx.dwICC = ICC_LISTVIEW_CLASSES;
			InitCommonControlsEx(&iccx);

			MSG  msg;
			WNDCLASS wc = { 0 };
			wc.lpszClassName = TEXT("OMCPPMainWin");
			HINSTANCE hInstance = GetModuleHandle(NULL);
			wc.hInstance = hInstance;
			wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
			wc.lpfnWndProc = WndProc;
			RegisterClass(&wc);
			screenWidth = GetSystemMetrics(SM_CXSCREEN);
			screenHeight = GetSystemMetrics(SM_CYSCREEN);
			uint32_t windowWidth, windowHeight;
			windowWidth = 800;
			windowHeight = 900;
			hwndMainWin = CreateWindowW(wc.lpszClassName, L"OsmAndMapCreator++", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, windowWidth, windowHeight, 0, 0, hInstance, 0);
			hwndStartBtn = CreateWindowEx(0, L"BUTTON", L"Convert", WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 650, 812, 120, 25, hwndMainWin, (HMENU)ID_STARTBTN, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndInputFilenameLabel = CreateWindowEx(0, L"STATIC", L"Input filename", WS_CHILD | WS_VISIBLE | SS_LEFT, 12, 680, 200, 20, hwndMainWin, NULL, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndOutputFilenameLabel = CreateWindowEx(0, L"STATIC", L"Output filename", WS_CHILD | WS_VISIBLE | SS_LEFT, 12, 710, 200, 20, hwndMainWin, NULL, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndInputFilenameField = CreateWindowEx(WS_EX_CLIENTEDGE, L"EDIT", utf8_to_wstring(inputFilename).c_str(), WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_LEFT, 100, 680, 390, 20, hwndMainWin, (HMENU)ID_INPUT_FILENAME_FIELD, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndOutputFilenameField = CreateWindowEx(WS_EX_CLIENTEDGE, L"EDIT", utf8_to_wstring(outputFilename).c_str(), WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_LEFT, 100, 708, 390, 20, hwndMainWin, (HMENU)ID_OUTPUT_FILENAME_FIELD, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndSplitLabel = CreateWindowEx(0, L"STATIC", L"Split mode", WS_CHILD | WS_VISIBLE | SS_LEFT, 12, 740, 150, 20, hwndMainWin, NULL, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndQuadtreeCombobox = CreateWindowEx(0, L"COMBOBOX", NULL, WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST, 100, 738, 140, 20, hwndMainWin, (HMENU)ID_QUADTREE_COMBOBOX, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			//SendMessage(hwndQuadtreeCombobox, CB_ADDSTRING, 0, (LPARAM)L"1-level quadtree 4:");
			SendMessage(hwndQuadtreeCombobox, CB_ADDSTRING, 0, (LPARAM)L"2-level quadtree 4:4:");
			SendMessage(hwndQuadtreeCombobox, CB_ADDSTRING, 0, (LPARAM)L"3-level quadtree 4:4:4:");
			if (forceSplitMode == -1) {
				SendMessage(hwndQuadtreeCombobox, CB_SETCURSEL, (WPARAM)1, 0);
				guiSelectedQuadtreeSplit = 1;
			} else {
				SendMessage(hwndQuadtreeCombobox, CB_SETCURSEL, (WPARAM)(forceSplitMode - 1), 0);
				guiSelectedQuadtreeSplit = (forceSplitMode - 1);
			}
			hwndSplitCombobox = CreateWindowEx(0, L"COMBOBOX", NULL, WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST, 250, 738, 240, 20, hwndMainWin, (HMENU)ID_SPLIT_COMBOBOX, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"Auto");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"1x1 (single box)");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"2x2 (4 boxes)");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"4x4 (16 boxes)");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"8x8 (64 boxes)");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"16x16 (256 boxes)");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"32x32 (1024 boxes)");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"64x64 (4096 boxes; max recommended)");
			SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"128x128 (16384 boxes; very slow to render)");
			//SendMessage(hwndSplitCombobox, CB_ADDSTRING, 0, (LPARAM)L"");
			SendMessage(hwndSplitCombobox, CB_SETCURSEL, (WPARAM)(forcedSplitPowerOf2 + 1), 0);
			guiSelectedSplitWithinQuadtree = (forcedSplitPowerOf2 + 1);
			calculateTotalRectanglesForGUI();
			hwndRectangleCountLabel = CreateWindowEx(0, L"STATIC", L"Data blocks", WS_CHILD | WS_VISIBLE | SS_LEFT, 500, 740, 200, 20, hwndMainWin, NULL, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			calculateTotalRectanglesForGUI();
			hwndDetailedVectorMapProgressLabel = CreateWindowEx(0, L"STATIC", L"Detailed map", WS_CHILD | WS_VISIBLE | SS_LEFT, 12, 770, 85, 20, hwndMainWin, NULL, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndDetailedVectorMapProgressBar = CreateWindowEx(0, PROGRESS_CLASS, NULL, WS_CHILD | WS_VISIBLE | SS_LEFT, 100, 768, 390, 20, hwndMainWin, NULL, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndProgressPercentLabel = CreateWindowEx(0, L"STATIC", L"0%", WS_VISIBLE | WS_CHILD | SS_LEFT, 500, 770, 80, 20, hwndMainWin, NULL, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			SendMessage(hwndDetailedVectorMapProgressBar, PBM_SETRANGE, 0, (WPARAM)MAKELONG(0, 65535));
			hwndInputFilenameBrowseButton = CreateWindowEx(0, L"BUTTON", L"Browse...", WS_TABSTOP | WS_VISIBLE | WS_CHILD, 500, 680, 80, 20, hwndMainWin, (HMENU)ID_BROWSE_INPUT_FILE, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			hwndOutputFilenameBrowseButton = CreateWindowEx(0, L"BUTTON", L"Browse...", WS_TABSTOP | WS_VISIBLE | WS_CHILD, 500, 708, 80, 20, hwndMainWin, (HMENU)ID_BROWSE_OUTPUT_FILE, (HINSTANCE)GetWindowLongPtr(hwndMainWin, GWLP_HINSTANCE), NULL);
			EnumChildWindows(hwndMainWin, (WNDENUMPROC)SetFont, (LPARAM)GetStockObject(DEFAULT_GUI_FONT));
			//if (!inputFilename.empty()) _beginthread(createOBFFile, 0, nullptr);
			thread t;
			if (!inputFilename.empty()) t = thread(createOBFFile, (void*)nullptr);

			while (GetMessage(&msg, NULL, 0, 0)) {
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
			delete[] progressBitmapPtr;
		#elif defined(__linux__)
			createOBFFile(nullptr);
		#endif
	} else {
		createOBFFile(nullptr);
	}
	#if defined(__linux__)
		cout << endl;
	#endif
	return 0;
}

void createOBFFile(void *param) {
	uint64_t overallStartTime = GetSystemTimeAsUnixTime();
	if (inputFilename.empty()) {
		cout << endl << "A database filename is required";
		return;
	}

	filesystem::path inputFilePath = inputFilename;

	//Use a default output filename if the user didn't choose one
	if (!foundOutputFilenameArgument) {
		filesystem::path outputFilenamePath = inputFilename;
		outputFilenamePath = outputFilenamePath.parent_path() / outputFilenamePath.stem();
		outputFilename = outputFilenamePath.string() + ".obf";
	}

	cout << endl << "Input file: \"" << inputFilename << "\"";
	cout << endl << "Output file: \"" << outputFilename << "\"";
	cout << endl << "Using " << sqliteCacheSizeMiBPerThread << " MiB cache, " << sqliteMMAPSizeMiBPerThread << " MiB MMAP (" << ((sqliteCacheSizeMiBPerThread + sqliteMMAPSizeMiBPerThread) << 2) << " MiB total peak RAM)";

	unique_ptr<unsigned char[]> fileCopyBufferUniquePtr = make_unique<unsigned char[]>(FILE_COPY_BUFFER_SIZE);
	unique_ptr<unsigned char[]> coordinatesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> typesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> additionalTypesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> stringNamesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	fileCopyBuffer = fileCopyBufferUniquePtr.get();

	databaseFilename = inputFilename;
	int rc = sqlite3_open_v2(inputFilename.c_str(), &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	if (rc != SQLITE_OK) {
		cout << endl << "Error opening database";
		sqlite3_close(db);
		return;
	}

	//Get the overall bounding rectangle
	uint64_t boundingRectangleStartTime;
	double boundingRectangleTime;
	boundingRectangleStartTime = GetSystemTimeAsUnixTime();
	string query = "select min(min_lon) as \"left\", min(min_lat) as bottom, max(max_lon) as \"right\", max(max_lat) as top from rtree_node;";
	rc = sqlite3_prepare_v2(db, query.c_str(), -1, &res, 0);
	if (rc != SQLITE_OK) {
		cout << endl << "Error while creating the overall bounding box prepared statement";
		return;
	}

	if (sqlite3_step(res) == SQLITE_ROW) {
		overallBoundingRectangle.left = sqlite3_column_double(res, 0);
		overallBoundingRectangle.bottom = sqlite3_column_double(res, 1);
		overallBoundingRectangle.right = sqlite3_column_double(res, 2);
		overallBoundingRectangle.top = sqlite3_column_double(res, 3);
		overallBoundingRectangle.calculateInt32ValuesFromDouble();
	} else {
		cout << endl << "Could not get the overall bounding rectangle";
		return;
	}
	sqlite3_finalize(res);
	boundingRectangleTime = (GetSystemTimeAsUnixTime() - boundingRectangleStartTime) / 1000.0;
	if (verbose) cout << endl << setprecision(12) << "Overall bounding rectangle: " << overallBoundingRectangle.left << ", " << overallBoundingRectangle.top << ", " << overallBoundingRectangle.right << ", " << overallBoundingRectangle.bottom << " (" << boundingRectangleTime << " second" << (boundingRectangleTime == 1 ? "" : "s") << ")";
	if (verbose) cout << endl << "(left, right, top, bottom) " << overallBoundingRectangle.leftInt32 << ", " << overallBoundingRectangle.rightInt32 << ", " << overallBoundingRectangle.topInt32 << ", " << overallBoundingRectangle.bottomInt32;
	if (verbose) cout << endl << "Bounding rectangle size(int32): width=" << (overallBoundingRectangle.rightInt32 - overallBoundingRectangle.leftInt32) << ", height=" << (overallBoundingRectangle.bottomInt32 - overallBoundingRectangle.topInt32);
	//TODO: split the map based on the int32 width and height

	ofstream output(outputFilename, ios::binary);
	google::protobuf::io::OstreamOutputStream ostream_output(&output);
	google::protobuf::io::CodedOutputStream cos(&ostream_output);

	//Version 2
	cos.WriteTag(OsmAnd::OBF::OsmAndStructure::kVersionFieldNumber << 3);
	cos.WriteVarint32(2);

	//Creation time (Unix milliseconds)
	cos.WriteTag(OsmAnd::OBF::OsmAndStructure::kDateCreatedFieldNumber << 3);
	cos.WriteVarint64(GetSystemTimeAsUnixTime());

	cos.WriteTag((OsmAnd::OBF::OsmAndStructure::kMapIndexFieldNumber << 3) | 6);
	//Save the MapIndex to a temp file but don't write it to the OBF file yet
	uint64_t mapIndexSize = 0;

	writeMapIndex(inputFilePath.stem().string());
	mapIndexSize = getFileSize(string("mapIndex_" + to_string(pid)));
	currentDiskUsage += mapIndexSize;
	//cout << endl << "mapIndex temp file size: " << mapIndexSize;
	writeOBFVarint32or64BE(cos, mapIndexSize);
	copyRawFileIntoCodedOutputStream(cos, "mapIndex_" + to_string(pid), mapIndexSize);
	if (!shouldKeepTempFiles) remove(string("mapIndex_" + to_string(pid)).c_str());
	currentDiskUsage = -mapIndexSize;

	//Version 2
	//cout << endl << "About to write versionConfirm";
	cos.WriteTag(OsmAnd::OBF::OsmAndStructure::kVersionConfirmFieldNumber << 3);
	cos.WriteVarint32(2);

	//sqlite3_finalize(res);
	sqlite3_close(db);
	/*int tmp;
	cout << endl << endl << "Enter a number to exit";
	cin >> tmp;*/

	uint64_t overallEndTime = GetSystemTimeAsUnixTime();
	double finishedSeconds = (overallEndTime - overallStartTime) / 1000.0;
	cout << endl << "Finished in " << (finishedSeconds < 10 ? to_string(finishedSeconds) + " seconds" : humanReadableTimeFromSeconds(finishedSeconds));
}

void calculateTotalRectanglesForGUI() {
	unsigned int totalRectangles = 0;
	wstring text = L"";
	switch (guiSelectedQuadtreeSplit) {
		case 0: //2-level quadtree
			{
				totalRectangles = 16;
			}
			break;
		case 1: //3-level quadtree
			{
				totalRectangles = 64;
			}
			break;
	}

	#if defined(_WIN32)
		if (guiSelectedSplitWithinQuadtree == 0 /* Auto */) {
			text = L"At least " + to_wstring((unsigned long)totalRectangles) + L" data blocks";
		} else {
			/*switch (guiSelectedSplitWithinQuadtree) {

			}*/
			totalRectangles *= ((1 << (guiSelectedSplitWithinQuadtree - 1)) * (1 << (guiSelectedSplitWithinQuadtree - 1)));
			text = to_wstring((unsigned long)totalRectangles) + L" data blocks";
		}
		SetWindowText(hwndRectangleCountLabel, text.c_str());
	#elif defined(__linux__)
	#endif
}

#if defined(_WIN32)
	LRESULT CALLBACK WndProc(HWND hwndMainWin, UINT msg, WPARAM wParam, LPARAM lParam) {
		RECT windowRect;
		int width, height;
		HDC hdc;
		HWND hctrlWnd;
		PAINTSTRUCT ps;
		HPEN h_LightGray_Pen, hOldPen;
		HGDIOBJ originalGDIObj;

		BITMAP bmp;
		HDC bmpHDC;
		LPMINMAXINFO lpMMI;

		//Making these static prevents odd drawing errors in WM_PAINT
		static int statusBarParts[4] = { 0, 0, 0, 0 };

		switch (msg) {
			case WM_CREATE:
				{
				//Apply the correct (non-bold) font to all the UI elements
				EnumChildWindows(hwndMainWin, (WNDENUMPROC)SetFont, (LPARAM)GetStockObject(DEFAULT_GUI_FONT));

				//Set the default cursor
				SetCursor(LoadCursor(0, IDC_ARROW));
				}
				break;
			case WM_PAINT:
				{
					{
						PAINTSTRUCT ps;
						HDC hdc = BeginPaint(hwndMainWin, &ps);
						RECT windowRect;
						HGDIOBJ hOldPen;
						HGDIOBJ hOldBrush;
						unsigned int progressAreaWidth, progressAreaHeight;
						GetWindowRect(hwndMainWin, &windowRect);
						progressAreaWidth = (windowRect.right - windowRect.left) - 28;
						progressAreaHeight = (windowRect.bottom - windowRect.top) - 250;
						if (progressBitmapWidth > 0 && progressBitmapHeight > 0) {
							SetStretchBltMode(hdc, COLORONCOLOR);
							HDC progressImageHDC = CreateCompatibleDC(hdc);
							BITMAP bm;
							bm.bmType = 0;
							bm.bmWidth = progressBitmapWidth;
							bm.bmHeight = progressBitmapHeight;
							bm.bmWidthBytes = progressBitmapWidth * 4;
							bm.bmPlanes = 1;
							bm.bmBitsPixel = 32;
							bm.bmBits = progressBitmapPtr;
							HBITMAP progressBitmap = CreateBitmapIndirect(&bm);
							SelectObject(progressImageHDC, progressBitmap);
							StretchBlt(hdc, 12, 12, progressAreaWidth - 12, progressAreaHeight - 12, progressImageHDC, 0, 0, progressBitmapWidth, progressBitmapHeight, SRCCOPY);
							DeleteObject(progressBitmap);
							DeleteDC(progressImageHDC);
						} else {
							HBRUSH hBrush = CreateSolidBrush(RGB(255, 255, 255));
							hOldPen = SelectObject(hdc, GetStockObject(NULL_PEN));
							hOldBrush = SelectObject(hdc, hBrush);
							Rectangle(hdc, 12, 12, progressAreaWidth + 1, progressAreaHeight + 1);
							SelectObject(hdc, hOldPen);
							SelectObject(hdc, hOldBrush);
							DeleteObject(hBrush);
						}

						//Draw the 3D edge
						MoveToEx(hdc, 10, 10, NULL);
						HPEN lightGrayOuterBorderColor = CreatePen(PS_SOLID, 1, RGB(208, 208, 208));
						HPEN lightGrayMiddleBorderColor = CreatePen(PS_SOLID, 1, RGB(128, 128, 128));
						HPEN darkGrayInnerBorderColor = CreatePen(PS_SOLID, 1, RGB(64, 64, 64));
						hOldPen = SelectObject(hdc, lightGrayOuterBorderColor);
						hOldBrush = SelectObject(hdc, GetStockObject(NULL_BRUSH));
						Rectangle(hdc, 10, 10, progressAreaWidth + 2, progressAreaHeight + 2);
						SelectObject(hdc, lightGrayMiddleBorderColor);
						MoveToEx(hdc, 11, 11, NULL);
						LineTo(hdc, progressAreaWidth, 11);
						SelectObject(hdc, darkGrayInnerBorderColor);
						MoveToEx(hdc, 12, 12, NULL);
						LineTo(hdc, progressAreaWidth - 1, 12);
						MoveToEx(hdc, 10, 11, NULL);
						SelectObject(hdc, lightGrayOuterBorderColor);
						SelectObject(hdc, lightGrayMiddleBorderColor);
						MoveToEx(hdc, 11, 12, NULL);
						LineTo(hdc, 11, progressAreaHeight);
						MoveToEx(hdc, 12, 13, NULL);
						SelectObject(hdc, darkGrayInnerBorderColor);
						LineTo(hdc, 12, progressAreaHeight - 1);
						MoveToEx(hdc, 12, progressAreaHeight - 1, NULL);
						SelectObject(hdc, lightGrayOuterBorderColor);
						LineTo(hdc, progressAreaWidth, progressAreaHeight - 1);
						MoveToEx(hdc, progressAreaWidth - 1, 12, NULL);
						SelectObject(hdc, lightGrayOuterBorderColor);
						LineTo(hdc, progressAreaWidth - 1, progressAreaHeight);
						MoveToEx(hdc, 11, progressAreaHeight, NULL);
						SelectObject(hdc, GetStockObject(WHITE_PEN));
						LineTo(hdc, progressAreaWidth - 1, progressAreaHeight);
						SelectObject(hdc, hOldBrush);
						SelectObject(hdc, hOldPen);
						DeleteObject(lightGrayOuterBorderColor);
						DeleteObject(lightGrayMiddleBorderColor);
						DeleteObject(darkGrayInnerBorderColor);
					
						EndPaint(hwndMainWin, &ps);
					}
				}
				break;
			case WM_SIZE:
				{
					RECT windowRect;
					unsigned int windowWidth, windowHeight;
					GetWindowRect(hwndMainWin, &windowRect);
					windowWidth = windowRect.right - windowRect.left;
					windowHeight = windowRect.bottom - windowRect.top;
					MoveWindow(hwndStartBtn, (windowWidth - 150), (windowHeight - 88), 120, 25, TRUE);
					MoveWindow(hwndInputFilenameLabel, 12, (windowHeight - 220), 200, 20, TRUE);
					MoveWindow(hwndOutputFilenameLabel, 12, (windowHeight - 190), 200, 20, TRUE);
					MoveWindow(hwndInputFilenameField, 100, (windowHeight - 220), 390, 20, TRUE);
					MoveWindow(hwndOutputFilenameField, 100, (windowHeight - 192), 390, 20, TRUE);
					MoveWindow(hwndSplitLabel, 12, (windowHeight - 160), 150, 20, TRUE);
					MoveWindow(hwndQuadtreeCombobox, 100, (windowHeight - 162), 140, 20, TRUE);
					MoveWindow(hwndSplitCombobox, 250, (windowHeight - 162), 240, 20, TRUE);
					MoveWindow(hwndRectangleCountLabel, 500, (windowHeight - 160), 200, 20, TRUE);
					MoveWindow(hwndDetailedVectorMapProgressLabel, 12, (windowHeight - 130), 85, 20, TRUE);
					MoveWindow(hwndDetailedVectorMapProgressBar, 100, (windowHeight - 132), 390, 20, TRUE);
					MoveWindow(hwndProgressPercentLabel, 500, (windowHeight - 130), 80, 20, TRUE);
					MoveWindow(hwndInputFilenameBrowseButton, 500, (windowHeight - 220), 80, 20, TRUE);
					MoveWindow(hwndOutputFilenameBrowseButton, 500, (windowHeight - 192), 80, 20, TRUE);
					InvalidateRect(hwndMainWin, NULL, TRUE);
					UpdateWindow(hwndMainWin);
				}
				break;
			case WM_COMMAND:
				{
					if (HIWORD(wParam) == BN_CLICKED) {
						switch (LOWORD(wParam)) {
							case ID_STARTBTN:
								{
									WCHAR buffer[MAX_PATH];
									GetWindowText(hwndInputFilenameField, buffer, MAX_PATH);
									inputFilename = wstring_to_utf8(wstring(buffer));
									GetWindowText(hwndOutputFilenameField, buffer, MAX_PATH);
									outputFilename = wstring_to_utf8(wstring(buffer));
									thread(createOBFFile, nullptr);
								}
								break;
							case ID_BROWSE_INPUT_FILE:
								{
									OPENFILENAME ofn;
									TCHAR szFileName[MAX_PATH] = L"";
									ZeroMemory(&ofn, sizeof(ofn));
									ofn.lStructSize = sizeof(ofn);
									ofn.hwndOwner = hwndMainWin;
									ofn.lpstrFilter = L"SQLite Database Files (*.db)\0*.db\0All Files (*.*)\0*.*\0";
									ofn.lpstrFile = szFileName;
									ofn.nMaxFile = MAX_PATH;
									ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
									ofn.lpstrDefExt = L"db";
									if (GetOpenFileName(&ofn)) SetWindowText(hwndInputFilenameField, szFileName);
									if (GetWindowTextLength(hwndOutputFilenameField) == 0) {
										filesystem::path outputFilenamePath = wstring(szFileName);
										outputFilenamePath = outputFilenamePath.parent_path() / outputFilenamePath.stem();
										outputFilename = outputFilenamePath.string() + ".obf";
										SetWindowText(hwndOutputFilenameField, utf8_to_wstring(outputFilename).c_str());
									}
								}
								break;
							case ID_BROWSE_OUTPUT_FILE:
								{
									OPENFILENAME ofn;
									TCHAR szFileName[MAX_PATH] = L"";
									ZeroMemory(&ofn, sizeof(ofn));
									ofn.lStructSize = sizeof(ofn);
									ofn.hwndOwner = hwndMainWin;
									ofn.lpstrFilter = L"OsmAnd OBF Files (*.obf)\0*.obf\0All Files (*.*)\0*.*\0";
									ofn.lpstrFile = szFileName;
									ofn.nMaxFile = MAX_PATH;
									ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
									ofn.lpstrDefExt = L"obf";
									if (GetSaveFileName(&ofn)) SetWindowText(hwndOutputFilenameField, szFileName);
								}
								break;
						}
					}

					if (LOWORD(wParam) == ID_QUADTREE_COMBOBOX) {
						guiSelectedQuadtreeSplit = SendMessage(hwndQuadtreeCombobox, CB_GETCURSEL, 0, 0);
						calculateTotalRectanglesForGUI();
					} else if (LOWORD(wParam) == ID_SPLIT_COMBOBOX) {
						guiSelectedSplitWithinQuadtree = SendMessage(hwndSplitCombobox, CB_GETCURSEL, 0, 0);
						calculateTotalRectanglesForGUI();
					}
				}
				break;
			case WM_USER_REDRAW:
				{
					SendMessage(hwndDetailedVectorMapProgressBar, PBM_SETPOS, (WPARAM)((unsigned int)((progressCompletedRectangles * 65535) / progressTotalRectangles)), 0);
					ostringstream percentStream;
					percentStream << fixed << setprecision(3) << ((progressCompletedRectangles * 100.0) / progressTotalRectangles);
					wstring percentString = utf8_to_wstring(percentStream.str());
					percentString += L"%";
					SendMessage(hwndProgressPercentLabel, WM_SETTEXT, 0, (LPARAM)percentString.c_str());
					InvalidateRect(hwndMainWin, NULL, TRUE);
					UpdateWindow(hwndMainWin);
				}
				break;
			case WM_DESTROY:
				PostQuitMessage(0);
				break;
		}
		return DefWindowProc(hwndMainWin, msg, wParam, lParam);
	}

	bool CALLBACK SetFont(HWND child, LPARAM font) {
		SendMessage(child, WM_SETFONT, font, true);
		return true;
	}
#endif

void printHelp() {
	cout << "OsmAndMapCreator++ version 0.1.12";
	cout << endl << endl << "This utility generates OBF map files for OsmAnd from an OpenStreetMap SQLite database";
	cout << endl << endl << "Usage:";
	cout << endl << "\t-i [path]\t\t\t\tInput filename (required)";
	cout << endl << "\t-o [path]\t\t\t\tOutput filename";
	cout << endl << "\t--keep-temp-files\t\t\tPreserve temp files for debugging (disabled by default)";
	//cout << endl << "\t--force-single-split [integer]\t\tForce a single power-of-2 split (for example, 2 would be 4x4)";
	cout << endl << "\t--force-quadtree2-split [integer]\tForce a 2-level quadtree split with a power-of-2 split in each section (for example, 2 would be 4:4:4x4). Takes precedence when combined with --force-single-split";
	cout << endl << "\t--force-quadtree3-split [integer]\tForce a 3-level quadtree split with a power-of-2 split in each section (for example, 2 would be 4:4:4:4x4). Takes precedence when combined with --force-quadtree2-split or --force-single-split";
	cout << endl << "\t--no-gui\t\t\t\tOnly show the command-line window";
	cout << endl << "\t--verbose\t\t\t\tPrint debug messages";
	cout << endl << "\t--cache-size\t\t\t\tSQLite per-thread cache size in MiB (default 64)";
	cout << endl << "\t--mmap-size\t\t\t\tSQLite per-thread memory-mapped file size in MiB (default 64)";
	cout << endl << "\t-h\t\t\t\t\tPrint this message";
}

uint64_t writeMapIndex(string name) {
	//Create a temp file for the MapIndex
	ofstream mapIndexTemp("mapIndex_" + to_string(pid), ios::binary);
	google::protobuf::io::OstreamOutputStream mapIndexTempOstream(&mapIndexTemp);
	google::protobuf::io::CodedOutputStream mapIndexCos(&mapIndexTempOstream);

	uint64_t mapIndexSize = 0;
	//MapIndex.name
	mapIndexCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::kNameFieldNumber << 3) | 2);
	//string mapIndexName = "OsmAndMapCreator++ test";
	mapIndexCos.WriteVarint32(name.length());
	mapIndexCos.WriteString(name);

	//MapIndex.rules
	//mapIndexCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::kRulesFieldNumber << 3) | 2); //" | 2" is the wire type
	writeOsmAndStructure_mapIndex_rules(mapIndexCos);

	//MapIndex.levels
	mapIndexCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::kLevelsFieldNumber << 3) | 6);
	unsigned int powerOf2Split = 1; //Start with 2x2 by default
	//Eventually we should set this automatically if the user didn't force a split option
	unsigned int multiplierForBlockSizeDivider = 16;
	if (forceSplitMode == 1 /* 2-level quadtree */) {
		multiplierForBlockSizeDivider = 16;
	} else if (forceSplitMode == 2 /* 3-level quadtree */) {
		multiplierForBlockSizeDivider = 8;
	}
	if (forceSplitMode >= 0) {
		powerOf2Split = forcedSplitPowerOf2;
	} else {
		//Automatically find a good split value
		powerOf2Split = getClosestNextLowerPowerOf2(max(overallBoundingRectangle.widthInt32 / (IDEAL_BLOCK_MAX_SIZE * multiplierForBlockSizeDivider), overallBoundingRectangle.heightInt32 / (IDEAL_BLOCK_MAX_SIZE * multiplierForBlockSizeDivider))); //Default to a bigger split (fewer blocks)
		#if defined(_WIN32)
			SendMessage(hwndSplitCombobox, CB_SETCURSEL, (WPARAM)(powerOf2Split + 1), 0);
		#endif
		guiSelectedSplitWithinQuadtree = powerOf2Split + 1;
		calculateTotalRectanglesForGUI();
	}
	
	if (forceSplitMode == -1 || forceSplitMode == 0 /* automatic or single split */) {
		//writeOsmAndStructure_mapIndex_detailed_level_single_power_of_2_split(powerOf2Split, false /* detailed zoom */);
		writeOsmAndStructure_mapIndex_detailed_level_4_4_4_pow2_split(powerOf2Split, false /* detailed zoom */);
	} else if (forceSplitMode == 1 /* 2-level quadtree */) {
		writeOsmAndStructure_mapIndex_detailed_level_4_4_pow2_split(powerOf2Split, false /* detailed zoom */);
	} else if (forceSplitMode == 2 /* 3-level quadtree */) {
		writeOsmAndStructure_mapIndex_detailed_level_4_4_4_pow2_split(powerOf2Split, false /* detailed zoom */);
	}
	int64_t mapRootLevelSize = getFileSize(string("mapRootLevel_" + to_string(pid)));
	writeOBFVarint32or64BE(mapIndexCos, mapRootLevelSize);
	//cout << endl << "mapRootLevel size = " << mapRootLevelSize;
	copyRawFileIntoCodedOutputStream(mapIndexCos, "mapRootLevel_" + to_string(pid), mapRootLevelSize);
	if (!shouldKeepTempFiles) remove(string("mapRootLevel_" + to_string(pid)).c_str());
	
	mapIndexCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::kLevelsFieldNumber << 3) | 6);
	if (powerOf2Split >= 4) {
		powerOf2Split -= 3;
	} else if (powerOf2Split >= 3) {
		powerOf2Split -= 2;
	}
	if (forceSplitMode == -1 || forceSplitMode == 0 /* automatic or single split */) {
		//writeOsmAndStructure_mapIndex_detailed_level_single_power_of_2_split(powerOf2Split, true /* detailed zoom */);
		writeOsmAndStructure_mapIndex_detailed_level_4_4_4_pow2_split(powerOf2Split, true /* detailed zoom */);
	} else if (forceSplitMode == 1 /* 2-level quadtree */) {
		writeOsmAndStructure_mapIndex_detailed_level_4_4_pow2_split(powerOf2Split, true /* detailed zoom */);
	} else if (forceSplitMode == 2 /* 3-level quadtree */) {
		writeOsmAndStructure_mapIndex_detailed_level_4_4_4_pow2_split(powerOf2Split, true /* detailed zoom */);
	}
	mapRootLevelSize = getFileSize(string("mapRootLevel_" + to_string(pid)));
	writeOBFVarint32or64BE(mapIndexCos, mapRootLevelSize);
	//cout << endl << "mapRootLevel size = " << mapRootLevelSize;
	copyRawFileIntoCodedOutputStream(mapIndexCos, "mapRootLevel_" + to_string(pid), mapRootLevelSize);
	if (!shouldKeepTempFiles) remove(string("mapRootLevel_" + to_string(pid)).c_str());
	return 0;
}

void writeOsmAndStructure_mapIndex_rules(google::protobuf::io::CodedOutputStream &cos) {
	string getKeysAndValuesQuery = GET_KEYS_AND_VALUES_SORTED_QUERY;
	getKeysAndValuesQuery.replace(getKeysAndValuesQuery.find("%HUMAN_READABLE_WHITELIST%"), 26, TAG_KEYS_HUMAN_READABLE_WHITELIST);
	getKeysAndValuesQuery.replace(getKeysAndValuesQuery.find("%MACHINE_READABLE_BLACKLIST%"), 28, TAG_KEYS_BLACKLIST);
	getKeysAndValuesQuery.replace(getKeysAndValuesQuery.find("%MACHINE_READABLE_BLACKLIST%"), 28, TAG_KEYS_BLACKLIST);
	int rc = sqlite3_prepare_v2(db, getKeysAndValuesQuery.c_str(), -1, &res, 0);
	uint64_t i = 2; //Reserve indices 0 and 1 for object_type=node and osmand_highway_integrity
	uint64_t rowCount = 0;
	uint64_t mapEncodingRuleSize = 0;
	OsmAnd::OBF::OsmAndMapIndex::MapEncodingRule r;
	string key, value;
	value = "";
	bool machineReadable = false;
	keyMap.emplace("object_type=node", 0);
	keyMap.emplace("osmand_highway_integrity=4", 1);

	r.Clear();
	r.set_tag("object_type");
	r.set_value("node");
	r.set_minzoom(5);
	r.set_type(1);
	cos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::kRulesFieldNumber << 3) | 2);
	cos.WriteVarint32(r.ByteSizeLong());
	r.SerializeToCodedStream(&cos);
	r.Clear();
	r.set_tag("osmand_highway_integrity");
	r.set_value("4");
	r.set_minzoom(5);
	r.set_type(1);
	cos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::kRulesFieldNumber << 3) | 2);
	cos.WriteVarint32(r.ByteSizeLong());
	r.SerializeToCodedStream(&cos);

	while ((rc = sqlite3_step(res)) == SQLITE_ROW) {
		if (i == 2) {
			rowCount = sqlite3_column_int64(res, 4);
			keyMap.reserve(rowCount);
			if (verbose) cout << endl << "Found " << rowCount << " unique key/value pair" << (rowCount == 1 ? "" : "s");
		}

		//These are tiny so we can generate them in memory instead of in a file
		r.Clear();
		key = string((char*)sqlite3_column_text(res, 0));
		value = string((char*)sqlite3_column_text(res, 1));
		machineReadable = sqlite3_column_int64(res, 2) == 0;
		if (machineReadable) {
			keyMap.emplace(key + "=" + value, i);
			if (!value.empty()) r.set_value(value);
			//cout << endl << "Added machine-readable tag " << key << "=" << value;
		} else {
			if (keyMap.find(key + "=") == keyMap.end()) {
				keyMap.emplace(key + "=", i);
			} else {
				continue; //Don't duplicate the human-readable keys like writing name= for every instance of the "name" tag
				//TODO: do this in SQL
			}
			//cout << endl << "Added human-readable key " << key << "=";
		}

		r.set_tag(key);
		r.set_minzoom(5);
		cos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::kRulesFieldNumber << 3) | 2);
		cos.WriteVarint32(r.ByteSizeLong());
		r.SerializeToCodedStream(&cos);

		i++;
	}
	sqlite3_finalize(res);
}

//OsmAndMapIndex.MapRootLevel
void writeOsmAndStructure_mapIndex_detailed_level_1x1(unsigned char *coordinatesByteArrayPtrWithinThread, unsigned char *typesByteArrayPtrWithinThread, unsigned char *additionalTypesByteArrayPtrWithinThread, unsigned char *stringNamesByteArrayPtrWithinThread) {
	remove(string("mapRootLevel_" + to_string(pid)).c_str());
	ofstream mapRootLevelTemp("mapRootLevel_" + to_string(pid), ios::binary);
	google::protobuf::io::OstreamOutputStream mapRootLevelTempOstream(&mapRootLevelTemp);
	google::protobuf::io::CodedOutputStream mapRootLevelTempCos(&mapRootLevelTempOstream);

	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMaxZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(22);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMinZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(15);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kLeftFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.leftInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kRightFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.rightInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kTopFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.topInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBottomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.bottomInt32);

	//MapRootLevel.boxes

	//For some reason, the box has to be built in an EXACT way that includes shiftToMapData with a wiretype of 6
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBoxesFieldNumber << 3) | 6);
	uint32_t boxSize = 0;
	boxSize += 4;
	boxSize++;
	boxSize += getVarintRequiredBytes(0);
	boxSize++;
	boxSize += getVarintRequiredBytes(0);
	boxSize++;
	boxSize += getVarintRequiredBytes(0);
	boxSize++;
	boxSize += getVarintRequiredBytes(0);
	boxSize++;
	boxSize = swap_endian(boxSize);
	mapRootLevelTempCos.WriteRaw(&boxSize, 4);
	boxSize = swap_endian(boxSize);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kShiftToMapDataFieldNumber << 3) | 6);
	//cout << endl << "boxSize=" << boxSize;
	boxSize++;
	boxSize = swap_endian(boxSize);
	mapRootLevelTempCos.WriteRaw(&boxSize, 4);

	//MapRootLevel.blocks
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
	//writeOsmAndStructure_mapIndex_levels_block("mapDataBlock_" + to_string(pid), &overallBoundingRectangle, 0, db, res, 0, coordinatesByteArrayPtrWithinThread, typesByteArrayPtrWithinThread, additionalTypesByteArrayPtrWithinThread, stringNamesByteArrayPtrWithinThread, false);
	uint64_t mapDataBlockSize = getFileSize(string("mapDataBlock_" + to_string(pid)));
	mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
	copyRawFileIntoCodedOutputStream(mapRootLevelTempCos, "mapDataBlock_" + to_string(pid), mapDataBlockSize);
	if (!shouldKeepTempFiles) remove(string("mapDataBlock_" + to_string(pid)).c_str());
}

//OsmAndMapIndex.MapRootLevel
void writeOsmAndStructure_mapIndex_detailed_level_single_power_of_2_split(int pow2, bool mediumZoom) {
	remove(string("mapRootLevel_" + to_string(pid)).c_str());
	ofstream mapRootLevelTemp("mapRootLevel_" + to_string(pid), ios::binary);
	google::protobuf::io::OstreamOutputStream mapRootLevelTempOstream(&mapRootLevelTemp);
	google::protobuf::io::CodedOutputStream mapRootLevelTempCos(&mapRootLevelTempOstream);

	int splitSectionCount = 1 << pow2;
	int totalBoxCount = 1 << (pow2 << 1);
	cout << endl << "Using " << (forceSplitMode >= 0 ? "user-defined" : "automatic") << " single " << splitSectionCount << "x" << splitSectionCount << " split (" << totalBoxCount << " box" << (totalBoxCount == 1 ? "" : "es") << ")";

	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMaxZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(mediumZoom ? 14 : 26);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMinZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(mediumZoom ? 5 : 15);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kLeftFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.leftInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kRightFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.rightInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kTopFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.topInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBottomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.bottomInt32);

	//MapRootLevel.boxes

	//Split the overall bounding box
	unique_ptr<BoundingRectangle[]> rectangles = make_unique<BoundingRectangle[]>(totalBoxCount);
	uint64_t singleBoxWidth, singleBoxHeight;
	singleBoxWidth = overallBoundingRectangle.widthInt32 >> pow2;
	singleBoxHeight = overallBoundingRectangle.heightInt32 >> pow2;
	cout << endl << "single box width=" << singleBoxWidth << ", height=" << singleBoxHeight;

	for (int y = 0; y < splitSectionCount; y++) {
		for (int x = 0; x < splitSectionCount; x++) {
			rectangles[(y * splitSectionCount) + x].leftInt32 = (overallBoundingRectangle.leftInt32 + (x * singleBoxWidth)) - NODE_BLOCK_OVERLAP;
			rectangles[(y * splitSectionCount) + x].rightInt32 = rectangles[(y * splitSectionCount) + x].leftInt32 + singleBoxWidth + NODE_BLOCK_OVERLAP;
			rectangles[(y * splitSectionCount) + x].topInt32 = (overallBoundingRectangle.topInt32 + (y * singleBoxHeight)) - NODE_BLOCK_OVERLAP;
			rectangles[(y * splitSectionCount) + x].bottomInt32 = (rectangles[(y * splitSectionCount) + x].topInt32 + singleBoxHeight + NODE_BLOCK_OVERLAP);
			rectangles[(y * splitSectionCount) + x].calculateDoubleValuesFromInt32();
			rectangles[(y * splitSectionCount) + x].expandByAbsoluteValue(2000); //2000 * 1/20 foot (100 feet)
			rectangles[(y * splitSectionCount) + x].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&overallBoundingRectangle);
			//cout << endl << "Rectangle " << (((y * splitSectionCount) + x) + 1) << " left, right, top, bottom:\t" << rectangles[(y * splitSectionCount) + x].left << ", " << rectangles[(y * splitSectionCount) + x].right << ", " << rectangles[(y * splitSectionCount) + x].top << ", " << rectangles[(y * splitSectionCount) + x].bottom;
		}
	}

	sqlite3_stmt *thread0Stmt, *thread1Stmt, *thread2Stmt, *thread3Stmt;
	thread0Stmt = nullptr;
	thread1Stmt = nullptr;
	thread2Stmt = nullptr;
	thread3Stmt = nullptr;
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread0StmtUniquePtr(thread0Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread1StmtUniquePtr(thread1Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread2StmtUniquePtr(thread2Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread3StmtUniquePtr(thread3Stmt);
	sqlite3 *thread0DBConnection, *thread1DBConnection, *thread2DBConnection, *thread3DBConnection;
	sqlite3_open_v2(databaseFilename.c_str(), &thread0DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread1DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread2DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread3DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	
	/*unique_ptr<unsigned char[]> coordinatesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> typesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> additionalTypesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> stringNamesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);*/
	array<unique_ptr<unsigned char[]>, 4> coordinatesByteArrayUniquePtrArrayForThreads;
	coordinatesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);
	
	array<unique_ptr<unsigned char[]>, 4> typesByteArrayUniquePtrArrayForThreads;
	typesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);
	
	array<unique_ptr<unsigned char[]>, 4> additionalTypesByteArrayUniquePtrArrayForThreads;
	additionalTypesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);
	
	array<unique_ptr<unsigned char[]>, 4> stringNamesByteArrayUniquePtrArrayForThreads;
	stringNamesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	MapDataBlockThreadInfo threadInfo[4];
	thread threadHandles[4];
	threadInfo[0].dbConnection = thread0DBConnection;
	threadInfo[0].stmt = thread0Stmt;
	threadInfo[1].dbConnection = thread1DBConnection;
	threadInfo[1].stmt = thread1Stmt;
	threadInfo[2].dbConnection = thread2DBConnection;
	threadInfo[2].stmt = thread2Stmt;
	threadInfo[3].dbConnection = thread3DBConnection;
	threadInfo[3].stmt = thread3Stmt;
	for (int i = 0; i < 4; i++) {
		threadInfo[i].rectangles = rectangles.get();
		threadInfo[i].rectanglesCount = totalBoxCount;
		threadInfo[i].threadID = i;
		threadInfo[i].coordinatesByteArrayPtrWithinThread = coordinatesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].typesByteArrayPtrWithinThread = typesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].additionalTypesByteArrayPtrWithinThread = additionalTypesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].stringNamesByteArrayPtrWithinThread = stringNamesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].mediumZoom = mediumZoom;
		threadHandles[i] = thread(writeOsmAndStructure_mapIndex_levels_block_SingleSplitThreadWorker, &threadInfo[i]);
	}

	cout << endl << "Waiting for threads...";
	for (int i = 0; i < 4; i++) threadHandles[i].join();
	cout << "done";
	unique_ptr<uint64_t[]> mapDataBlockSizes = make_unique<uint64_t[]>(totalBoxCount);
	for (int i = 0; i < totalBoxCount; i++) mapDataBlockSizes[i] = getFileSize(string("mapDataBlock" + to_string(i) + ".tmp"));

	if (thread0Stmt != nullptr) {
		sqlite3_finalize(thread0Stmt);
		thread0Stmt = nullptr;
	}
	if (thread1Stmt != nullptr) {
		sqlite3_finalize(thread1Stmt);
		thread1Stmt = nullptr;
	}
	if (thread2Stmt != nullptr) {
		sqlite3_finalize(thread2Stmt);
		thread2Stmt = nullptr;
	}
	if (thread3Stmt != nullptr) {
		sqlite3_finalize(thread3Stmt);
		thread3Stmt = nullptr;
	}
	sqlite3_close(thread0DBConnection);
	sqlite3_close(thread1DBConnection);
	sqlite3_close(thread2DBConnection);
	sqlite3_close(thread3DBConnection);
	
	//MapRootLevel.boxes
	//Write these after generating the data blocks so we don't have to wait to find the offsets

	//For some reason, the box has to be built in an EXACT way that includes shiftToMapData with a wiretype of 6

	//We need a root box to contain the other ones because it can't process more than one top-level box
	if (verbose) cout << endl << "Box sizes: ";
	uint32_t boxSize = 0;
	boxSize = 1 + getVarintRequiredBytes(0) + 1 + getVarintRequiredBytes(0) + 1 + getVarintRequiredBytes(0) + 1 + getVarintRequiredBytes(0);
	for (int i = 0; i < totalBoxCount; i++) {
		if (verbose) cout << rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		boxSize += 1 + 4 + rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		if (verbose && i < totalBoxCount - 1) cout << ", ";
	}

	//Root box
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBoxesFieldNumber << 3) | 6);
	//cout << endl << "Root box size: " << boxSize;
	boxSize = swap_endian(boxSize);
	mapRootLevelTempCos.WriteRaw(&boxSize, 4);
	//boxSize = swap_endian(boxSize);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	
	/*This should be
		[current boxSize_without_tag_and_fixed32size] +
		[all future boxes with tag and fixed32 size] +
		[sizes of any undesired MapDataBlocks + tag and varint size] +
		[desired box's tag]
	so the offset is from MapDataBox.left_tag to MapDataBlock.varint_size*/
	uint32_t shiftToMapData = 0;
	for (int i = 0; i < totalBoxCount; i++) {
		shiftToMapData = rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		//Add the future MapDataBoxes
		for (int j = i + 1; j < totalBoxCount; j++) {
			shiftToMapData += 1 + 4 + rectangles[j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		}
		//Add the future MapDataBlocks
		for (int j = 0; j < i; j++) {
			shiftToMapData += 1 + getVarintRequiredBytes(mapDataBlockSizes[j]) + mapDataBlockSizes[j];
		}
		shiftToMapData++; //Skip the MapDataBlock tag

		mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
		boxSize = rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		boxSize = swap_endian(boxSize);
		mapRootLevelTempCos.WriteRaw(&boxSize, 4);
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].leftInt32) - ((int64_t)overallBoundingRectangle.leftInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].rightInt32) - ((int64_t)overallBoundingRectangle.rightInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].topInt32) - ((int64_t)overallBoundingRectangle.topInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].bottomInt32) - ((int64_t)overallBoundingRectangle.bottomInt32)));
		mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kShiftToMapDataFieldNumber << 3) | 6);
		shiftToMapData = swap_endian(shiftToMapData);
		mapRootLevelTempCos.WriteRaw(&shiftToMapData, 4);
	}
	
	//Write the MapDataBlocks
	//We should delete the temp files as we copy them to save space
	for (int i = 0; i < totalBoxCount; i++) {
		mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
		mapRootLevelTempCos.WriteVarint32(mapDataBlockSizes[i]);
		copyRawFileIntoCodedOutputStream(mapRootLevelTempCos, "mapDataBlock_" + to_string(pid) + to_string(i) + ".tmp", mapDataBlockSizes[i]);
		if (!shouldKeepTempFiles) remove(string("mapDataBlock_" + to_string(pid) + to_string(i) + ".tmp").c_str());
	}
}

//OsmAndMapIndex.MapRootLevel
//This mode splits the map into a 2-level quadtree and uses a power-of-2 split in all 16 sections
void writeOsmAndStructure_mapIndex_detailed_level_4_4_pow2_split(int pow2, bool mediumZoom) {
	remove(string("mapRootLevel_" + to_string(pid)).c_str());
	ofstream mapRootLevelTemp("mapRootLevel_" + to_string(pid), ios::binary);
	google::protobuf::io::OstreamOutputStream mapRootLevelTempOstream(&mapRootLevelTemp);
	google::protobuf::io::CodedOutputStream mapRootLevelTempCos(&mapRootLevelTempOstream);

	int splitSectionCount = 1 << pow2;
	int totalBoxCount = (1 << (pow2 << 1)) << 4;
	cout << endl << "Using " << (forceSplitMode >= 0 ? "user-defined" : "automatic") << " 4:4:" << splitSectionCount << "x" << splitSectionCount << " split (" << totalBoxCount << " data boxes)";

	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMaxZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(mediumZoom ? 14 : 26);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMinZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(mediumZoom ? 5 : 15);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kLeftFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.leftInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kRightFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.rightInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kTopFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.topInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBottomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.bottomInt32);

	uint64_t singleBoxWidth, singleBoxHeight;
	singleBoxWidth = (overallBoundingRectangle.widthInt32 >> pow2) >> 2;
	singleBoxHeight = (overallBoundingRectangle.heightInt32 >> pow2) >> 2;
	cout << endl << "single box width=" << singleBoxWidth << ", height=" << singleBoxHeight;

	//MapRootLevel.boxes
	unique_ptr<BoundingRectangle[]> quadtreeLevel1Rectangles = make_unique<BoundingRectangle[]>(4);
	unique_ptr<BoundingRectangle[]> quadtreeLevel2Rectangles = make_unique<BoundingRectangle[]>(16);
	//Split the overall bounding box
	unique_ptr<BoundingRectangle[]> rectangles = make_unique<BoundingRectangle[]>(totalBoxCount);
	for (unsigned int y = 0; y < 2; y++) {
		for (unsigned int x = 0; x < 2; x++) {
			quadtreeLevel1Rectangles[(y * 2) + x].leftInt32 = (overallBoundingRectangle.leftInt32 + (x * (overallBoundingRectangle.widthInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(y * 2) + x].rightInt32 = (overallBoundingRectangle.leftInt32 + ((x + 1) * (overallBoundingRectangle.widthInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(y * 2) + x].topInt32 = (overallBoundingRectangle.topInt32 + (y * (overallBoundingRectangle.heightInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(y * 2) + x].bottomInt32 = (overallBoundingRectangle.topInt32 + ((y + 1) * (overallBoundingRectangle.heightInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(y * 2) + x].calculateDoubleValuesFromInt32();
			quadtreeLevel1Rectangles[(y * 2) + x].expandByAbsoluteValue(8000);
			quadtreeLevel1Rectangles[(y * 2) + x].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&overallBoundingRectangle);
			quadtreeLevel1Rectangles[(y * 2) + x].MapDataBoxBytesSizeWithoutTagAndFixed32Size -= (1 + 4); //Quadtree boxes don't have shiftToMapData
			//if (verbose) cout << endl << "Quadtree level 1 rectangle " << (((y * 2) + x) + 1) << ": " << quadtreeLevel1Rectangles[(y * 2) + x].left << ", " << quadtreeLevel1Rectangles[(y * 2) + x].right << ", " << quadtreeLevel1Rectangles[(y * 2) + x].bottom << ", " << quadtreeLevel1Rectangles[(y * 2) + x].top;

			//Generate the 4 level-2 quadtree boxes
			for (unsigned int y2 = 0; y2 < 2; y2++) {
				for (unsigned int x2 = 0; x2 < 2; x2++) {
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].leftInt32 = (quadtreeLevel1Rectangles[(y * 2) + x].leftInt32 + (x2 * (quadtreeLevel1Rectangles[(y * 2) + x].widthInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].rightInt32 = (quadtreeLevel1Rectangles[(y * 2) + x].leftInt32 + ((x2 + 1) * (quadtreeLevel1Rectangles[(y * 2) + x].widthInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].topInt32 = (quadtreeLevel1Rectangles[(y * 2) + x].topInt32 + (y2 * (quadtreeLevel1Rectangles[(y * 2) + x].heightInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].bottomInt32 = (quadtreeLevel1Rectangles[(y * 2) + x].topInt32 + ((y2 + 1) * (quadtreeLevel1Rectangles[(y * 2) + x].heightInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].calculateDoubleValuesFromInt32();
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].expandByAbsoluteValue(8000);
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&(quadtreeLevel1Rectangles[(y * 2) + x]));
					quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].MapDataBoxBytesSizeWithoutTagAndFixed32Size -= (1 + 4);
					for (unsigned int j = 0; j < splitSectionCount; j++) {
						for (unsigned int i = 0; i < splitSectionCount; i++) {
							rectangles[(((((y /* level 1 quadtree Y */ * 2) + x /* level 1 quadtree X */) * 4) + (y2 /* level 2 quadtree Y */ * 2) + x2 /* level 2 quadtree X */) * (splitSectionCount * splitSectionCount)) + ((j /* Y of MapDataBox within level 2 quadtree box */ * splitSectionCount) + i /* X of MapDataBox within level 2 quadtree box */)].leftInt32 = (quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].leftInt32 + (i * singleBoxWidth));
							rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].rightInt32 = rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].leftInt32 + singleBoxWidth;
							rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].topInt32 = (quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].topInt32 + (j * singleBoxHeight));
							rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].bottomInt32 = (rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].topInt32 + singleBoxHeight);
							rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].calculateDoubleValuesFromInt32();
							rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].expandByAbsoluteValue(8000);
							rectangles[(((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&(quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2]));
							//cout << endl << "Rectangle " << ((((((y * 2) + x) * 4) + (y2 * 2) + x2) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i));
						}
					}
					//if (verbose) cout << endl << "\tQuadtree level 2 rectangle " << (((y2 * 2) + x2) + 1) << " (overall quadtree index " << ((((y * 2) + x) * 4) + (y2 * 2) + x2) << "): " << quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].left << ", " << quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].right << ", " << quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].bottom << ", " << quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + (y2 * 2) + x2].top;
				}
			}
		}
	}

	sqlite3_stmt *thread0Stmt, *thread1Stmt, *thread2Stmt, *thread3Stmt;
	thread0Stmt = nullptr;
	thread1Stmt = nullptr;
	thread2Stmt = nullptr;
	thread3Stmt = nullptr;
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread0StmtUniquePtr(thread0Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread1StmtUniquePtr(thread1Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread2StmtUniquePtr(thread2Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread3StmtUniquePtr(thread3Stmt);
	sqlite3 *thread0DBConnection, *thread1DBConnection, *thread2DBConnection, *thread3DBConnection;
	sqlite3_open_v2(databaseFilename.c_str(), &thread0DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread1DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread2DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread3DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	unique_ptr<uint64_t[]> mapDataBlockSizes = make_unique<uint64_t[]>(totalBoxCount);

	/*unique_ptr<unsigned char[]> coordinatesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> typesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> additionalTypesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> stringNamesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);*/
	array<unique_ptr<unsigned char[]>, 4> coordinatesByteArrayUniquePtrArrayForThreads;
	coordinatesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	array<unique_ptr<unsigned char[]>, 4> typesByteArrayUniquePtrArrayForThreads;
	typesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	array<unique_ptr<unsigned char[]>, 4> additionalTypesByteArrayUniquePtrArrayForThreads;
	additionalTypesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	array<unique_ptr<unsigned char[]>, 4> stringNamesByteArrayUniquePtrArrayForThreads;
	stringNamesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	MapDataBlockThreadInfo threadInfo[4];
	thread threadHandles[4];
	threadInfo[0].dbConnection = thread0DBConnection;
	threadInfo[0].stmt = thread0Stmt;
	threadInfo[1].dbConnection = thread1DBConnection;
	threadInfo[1].stmt = thread1Stmt;
	threadInfo[2].dbConnection = thread2DBConnection;
	threadInfo[2].stmt = thread2Stmt;
	threadInfo[3].dbConnection = thread3DBConnection;
	threadInfo[3].stmt = thread3Stmt;
	for (int i = 0; i < 4; i++) {
		threadInfo[i].rectangles = rectangles.get();
		threadInfo[i].rectanglesCount = totalBoxCount;
		threadInfo[i].threadID = i;
		threadInfo[i].coordinatesByteArrayPtrWithinThread = coordinatesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].typesByteArrayPtrWithinThread = typesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].additionalTypesByteArrayPtrWithinThread = additionalTypesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].stringNamesByteArrayPtrWithinThread = stringNamesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].mediumZoom = mediumZoom;
		threadInfo[i].mapDataBlockSizes = mapDataBlockSizes.get();
		threadHandles[i] = thread(writeOsmAndStructure_mapIndex_levels_block_SingleSplitThreadWorker, &threadInfo[i]);
	}

	cout << endl << "Waiting for threads...";
	for (int i = 0; i < 4; i++) threadHandles[i].join();
	cout << "done";
	//for (int i = 0; i < (totalBoxCount); i++) mapDataBlockSizes[i] = getFileSize(utf8_to_wstring(string("mapDataBlock" + to_string(i) + ".tmp")).c_str());

	if (thread0Stmt != nullptr) {
		sqlite3_finalize(thread0Stmt);
		thread0Stmt = nullptr;
	}
	if (thread1Stmt != nullptr) {
		sqlite3_finalize(thread1Stmt);
		thread1Stmt = nullptr;
	}
	if (thread2Stmt != nullptr) {
		sqlite3_finalize(thread2Stmt);
		thread2Stmt = nullptr;
	}
	if (thread3Stmt != nullptr) {
		sqlite3_finalize(thread3Stmt);
		thread3Stmt = nullptr;
	}
	sqlite3_close(thread0DBConnection);
	sqlite3_close(thread1DBConnection);
	sqlite3_close(thread2DBConnection);
	sqlite3_close(thread3DBConnection);
	
	//Dynamic threading code that we can enable later
	/*sqlite3_stmt **threadStmt = new sqlite3_stmt*[threads];
	sqlite3 **threadDBConnections = new sqlite3*[threads];
	vector<unique_ptr<unsigned char[]>> coordinatesByteArrayUniquePtrArrayForThreads;
	vector<unique_ptr<unsigned char[]>> typesByteArrayUniquePtrArrayForThreads;
	vector<unique_ptr<unsigned char[]>> additionalTypesByteArrayUniquePtrArrayForThreads;
	vector<unique_ptr<unsigned char[]>> stringNamesByteArrayUniquePtrArrayForThreads;
	MapDataBlockThreadInfo *threadInfo = new MapDataBlockThreadInfo[threads];
	uintptr_t *threadHandles = new uintptr_t[threads];
	for (unsigned int i = 0; i < threads; i++) {
		threadStmt[i] = nullptr;
		sqlite3_open_v2(databaseFilename.c_str(), &(threadDBConnections[i]), SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
		coordinatesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));
		typesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));
		additionalTypesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));
		stringNamesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));

		threadInfo[i].dbConnection = threadDBConnections[i];
		threadInfo[i].stmt = threadStmt[i];
		threadInfo[i].rectangles = rectangles.get();
		threadInfo[i].rectanglesCount = totalBoxCount;
		threadInfo[i].threadID = i;
		threadInfo[i].coordinatesByteArrayPtrWithinThread = coordinatesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].typesByteArrayPtrWithinThread = typesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].additionalTypesByteArrayPtrWithinThread = additionalTypesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].stringNamesByteArrayPtrWithinThread = stringNamesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].mediumZoom = mediumZoom;
		threadHandles[i] = _beginthread(writeOsmAndStructure_mapIndex_levels_block_SingleSplitThreadWorker, 0, &(threadInfo[i]));
	}

	cout << endl << "Waiting for threads...";
	for (int i = 0; i < threads; i++) WaitForSingleObject((HANDLE)threadHandles[i], INFINITE);
	cout << "done";
	unique_ptr<uint64_t[]> mapDataBlockSizes = make_unique<uint64_t[]>(totalBoxCount);
	for (int i = 0; i < totalBoxCount; i++) mapDataBlockSizes[i] = getFileSize(utf8_to_wstring(string("mapDataBlock" + to_string(i) + ".tmp")).c_str());

	delete[] threadInfo;
	delete[] threadHandles;
	for (unsigned int i = 0; i < threads; i++) {
		if (threadStmt[i] != nullptr) sqlite3_finalize(threadStmt[i]);
		threadStmt[i] = nullptr;
		sqlite3_close(threadDBConnections[i]);
	}
	delete[] threadDBConnections;
	delete[] threadStmt;*/

	//MapRootLevel.boxes
	//Write these after generating the data blocks so we don't have to wait to find the offsets

	unique_ptr<uint64_t[]> quadtreeLevel1ByteSizesIncludingAllSubBoxes = make_unique<uint64_t[]>(4);
	unique_ptr<uint64_t[]> quadtreeLevel2ByteSizesIncludingAllSubBoxes = make_unique<uint64_t[]>(16);
	uint64_t level1BoxSize, level2BoxSize;
	uint32_t rootBoxSize, boxSize;
	rootBoxSize = 1 + getVarintRequiredBytes(0) /* left */ + 1 + getVarintRequiredBytes(0) /* right */ + 1 + getVarintRequiredBytes(0) /* top */ + 1 + getVarintRequiredBytes(0) /* bottom */;
	for (int y = 1; y >= 0; y--) {
		for (int x = 1; x >= 0; x--) {
			level1BoxSize = quadtreeLevel1Rectangles[(y * 2) + x].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
			for (int y2 = 1; y2 >= 0; y2--) {
				for (int x2 = 1; x2 >= 0; x2--) {
					level2BoxSize = quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
					for (unsigned int i = 0; i < (splitSectionCount * splitSectionCount); i++) {
						level2BoxSize += 1 + 4 + rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * (splitSectionCount * splitSectionCount)) + i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
					}
					quadtreeLevel2ByteSizesIncludingAllSubBoxes[(((y * 2) + x) * 4) + ((y2 * 2) + x2)] = level2BoxSize;
					//cout << endl << "\tQuadtree level 2 box " << (((y2 * 2) + x2) + 1) << " (overall box " << ((((y * 2) + x) * 4) + ((y2 * 2) + x2)) << ") byte size without tag and fixed32 size: " << level2BoxSize;
					level1BoxSize += 1 + 4 + level2BoxSize;
				}
			}
			quadtreeLevel1ByteSizesIncludingAllSubBoxes[(y * 2) + x] = level1BoxSize;
			rootBoxSize += 1 + 4 + level1BoxSize;
			//cout << endl << "Quadtree level 1 box " << (((y * 2) + x) + 1) << " byte size without tag and fixed32 size: " << level1BoxSize;
		}
	}
	
	//For some reason, the boxes with data have to be built in an EXACT way that includes shiftToMapData with a wiretype of 6

	//We need a root box to contain the other ones because it can't process more than one top-level box
	/*if (verbose) cout << endl << "Box sizes: ";
	uint32_t boxSize = 0;
	for (int i = 0; i < totalBoxCount; i++) {
		if (verbose) cout << rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		boxSize += 1 + 4 + rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		if (verbose && i < totalBoxCount - 1) cout << ", ";
	}*/

	//Root box
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBoxesFieldNumber << 3) | 6);
	//cout << endl << "Root box size: " << boxSize;
	rootBoxSize = swap_endian(rootBoxSize);
	mapRootLevelTempCos.WriteRaw(&rootBoxSize, 4);
	//boxSize = swap_endian(boxSize);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);

	unsigned int boxesWithinLevel2Quadtree = (splitSectionCount * splitSectionCount);
	uint32_t shiftToMapData = 0;
	for (unsigned int y = 0; y < 2; y++) {
		for (unsigned int x = 0; x < 2; x++) {
			//Top-level quadtree boxes
			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
			boxSize = quadtreeLevel1ByteSizesIncludingAllSubBoxes[(y * 2) + x] /*- (1 + 4)*/;
			//Add the 4 level-2 quadtree box sizes and their sub-boxes
			/*for (int i = 0; i < 4; i++) {
				//Level-2 quadtree box
				boxSize += 1 + 4 + quadtreeLevel2ByteSizes[(((y * 2) + x) * 4) + i];

				//Sub-boxes
				for (int j = 0; j < (splitSectionCount * splitSectionCount); j++) boxSize += 1 + 4 + rectangles[(((((y * 2) + x) * 4) + i) * (splitSectionCount * splitSectionCount)) + j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
			}*/
			boxSize = swap_endian(boxSize);
			mapRootLevelTempCos.WriteRaw(&boxSize, 4);
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].leftInt32) - ((int64_t)overallBoundingRectangle.leftInt32)));
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].rightInt32) - ((int64_t)overallBoundingRectangle.rightInt32)));
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].topInt32) - ((int64_t)overallBoundingRectangle.topInt32)));
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].bottomInt32) - ((int64_t)overallBoundingRectangle.bottomInt32)));
			for (unsigned int y2 = 0; y2 < 2; y2++) {
				for (unsigned int x2 = 0; x2 < 2; x2++) {
					//Level-2 quadtree boxes
					mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
					boxSize = quadtreeLevel2ByteSizesIncludingAllSubBoxes[(((y * 2) + x) * 4) + ((y2 * 2) + x2)] /*- (1 + 4)*/;
					//for (int j = 0; j < (splitSectionCount * splitSectionCount); j++) boxSize += 1 + 4 + rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * (splitSectionCount * splitSectionCount)) + j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
					boxSize = swap_endian(boxSize);
					mapRootLevelTempCos.WriteRaw(&boxSize, 4);
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].leftInt32) - ((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].leftInt32)));
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].rightInt32) - ((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].rightInt32)));
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].topInt32) - ((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].topInt32)));
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].bottomInt32) - ((int64_t)quadtreeLevel1Rectangles[(y * 2) + x].bottomInt32)));
					for (int j = 0; j < boxesWithinLevel2Quadtree; j++) {
						mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
						boxSize = rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * boxesWithinLevel2Quadtree) + j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
						boxSize = swap_endian(boxSize);
						mapRootLevelTempCos.WriteRaw(&boxSize, 4);
						mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
						mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * boxesWithinLevel2Quadtree) + j].leftInt32) - ((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].leftInt32)));
						mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
						mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * boxesWithinLevel2Quadtree) + j].rightInt32) - ((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].rightInt32)));
						mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
						mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * boxesWithinLevel2Quadtree) + j].topInt32) - ((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].topInt32)));
						mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
						mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * boxesWithinLevel2Quadtree) + j].bottomInt32) - ((int64_t)quadtreeLevel2Rectangles[(((y * 2) + x) * 4) + ((y2 * 2) + x2)].bottomInt32)));
						//shiftToMapData
						//Add the sizes of the future sub-boxes in this level 2 quadtree block + the other level 1 quadtree blocks + the sizes of the data blocks before the current one
						shiftToMapData = 0;
						//Add the future blocks within the current level 2 quadtree
						for (int k = j; k < boxesWithinLevel2Quadtree; k++) {
							shiftToMapData += (k > j ? (1 + 4) : 0) /* Don't add our (the current sub-box's) tag and fixed32 size since we're starting from the MapDatBox.left tag */ + rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * boxesWithinLevel2Quadtree) + /*j*/k].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
						}
						//Add the future level 2 quadtree blocks
						for (unsigned int k = (((y2 * 2) + x2) + 1); k < 4; k++) {
							shiftToMapData += 1 + 4 + quadtreeLevel2ByteSizesIncludingAllSubBoxes[k];
						}
						//Add the future level 1 quadtree blocks
						for (unsigned int k = (((y * 2) + x) + 1); k < 4; k++) {
							shiftToMapData += 1 + 4 + quadtreeLevel1ByteSizesIncludingAllSubBoxes[k];
						}
						//Add the future MapDataBlock sizes
						for (unsigned int k = 0; k < ((((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * boxesWithinLevel2Quadtree) + j); k++) {
							shiftToMapData += 1 + getVarintRequiredBytes(mapDataBlockSizes[k]) + mapDataBlockSizes[k];
						}
						shiftToMapData++;
						mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kShiftToMapDataFieldNumber << 3) | 6);
						shiftToMapData = swap_endian(shiftToMapData);
						mapRootLevelTempCos.WriteRaw(&shiftToMapData, 4);
					}
				}
			}
		}
	}

	/*This should be
		[current boxSize_without_tag_and_fixed32size] +
		[all future boxes with tag and fixed32 size] +
		[sizes of any undesired MapDataBlocks + tag and varint size] +
		[desired box's tag]
	so the offset is from MapDataBox.left_tag to MapDataBlock.varint_size*/
	/*uint32_t shiftToMapData = 0;
	for (int i = 0; i < totalBoxCount; i++) {
		shiftToMapData = rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		//Add the future MapDataBoxes
		for (int j = i + 1; j < totalBoxCount; j++) {
			shiftToMapData += 1 + 4 + rectangles[j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		}
		//Add the future MapDataBlocks
		for (int j = 0; j < i; j++) {
			shiftToMapData += 1 + getVarintRequiredBytes(mapDataBlockSizes[j]) + mapDataBlockSizes[j];
		}
		shiftToMapData++; //Skip the MapDataBlock tag

		mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
		boxSize = rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		boxSize = swap_endian(boxSize);
		mapRootLevelTempCos.WriteRaw(&boxSize, 4);
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].leftInt32) - ((int64_t)overallBoundingRectangle.leftInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].rightInt32) - ((int64_t)overallBoundingRectangle.rightInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].topInt32) - ((int64_t)overallBoundingRectangle.topInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].bottomInt32) - ((int64_t)overallBoundingRectangle.bottomInt32)));
		mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kShiftToMapDataFieldNumber << 3) | 6);
		shiftToMapData = swap_endian(shiftToMapData);
		mapRootLevelTempCos.WriteRaw(&shiftToMapData, 4);
	}*/

	//Write the MapDataBlocks
	//We should delete the temp files as we copy them to save space
	{
		ifstream thread1TempFile("thread0_" + to_string(pid) + ".tmp", ios::binary);
		ifstream thread2TempFile("thread1_" + to_string(pid) + ".tmp", ios::binary);
		ifstream thread3TempFile("thread2_" + to_string(pid) + ".tmp", ios::binary);
		ifstream thread4TempFile("thread3_" + to_string(pid) + ".tmp", ios::binary);
		uint32_t mapDataBlockSize;
		for (int i = 0; i < totalBoxCount / 4; i++) {
			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread1TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread1TempFile, mapDataBlockSize);

			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread2TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread2TempFile, mapDataBlockSize);

			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread3TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread3TempFile, mapDataBlockSize);

			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread4TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread4TempFile, mapDataBlockSize);
		}
	}
	if (!shouldKeepTempFiles) {
		remove(string("thread0_" + to_string(pid) + ".tmp").c_str());
		remove(string("thread1_" + to_string(pid) + ".tmp").c_str());
		remove(string("thread2_" + to_string(pid) + ".tmp").c_str());
		remove(string("thread3_" + to_string(pid) + ".tmp").c_str());
	}
}

//OsmAndMapIndex.MapRootLevel
//This mode splits the map into a 3-level quadtree and uses a power-of-2 split in all 64 sections
void writeOsmAndStructure_mapIndex_detailed_level_4_4_4_pow2_split(int pow2, bool mediumZoom) {
	remove(string("mapRootLevel_" + to_string(pid)).c_str());
	ofstream mapRootLevelTemp("mapRootLevel_" + to_string(pid), ios::binary);
	google::protobuf::io::OstreamOutputStream mapRootLevelTempOstream(&mapRootLevelTemp);
	google::protobuf::io::CodedOutputStream mapRootLevelTempCos(&mapRootLevelTempOstream);

	int splitSectionCount = 1 << pow2;
	int totalBoxCount = (1 << (pow2 << 1)) << 6;
	progressBitmapWidth = 2 * 2 * 2 * splitSectionCount;
	progressBitmapHeight = 2 * 2 * 2 * splitSectionCount;
	if (shouldShowGUI) {
		delete[] progressBitmapPtr;
		progressBitmapPtr = new unsigned char[progressBitmapWidth * progressBitmapHeight * 4];
		memset(progressBitmapPtr, 255, (progressBitmapWidth * progressBitmapHeight * 4));
	}
	cout << endl << "Using " << (forceSplitMode >= 0 ? "user-defined" : "automatic") << " 4:4:4:" << splitSectionCount << "x" << splitSectionCount << " split (" << totalBoxCount << " data boxes)";

	uint64_t singleBoxWidth, singleBoxHeight;
	singleBoxWidth = (overallBoundingRectangle.widthInt32 >> pow2) >> 3;
	singleBoxHeight = (overallBoundingRectangle.heightInt32 >> pow2) >> 3;
	cout << endl << "single box width=" << singleBoxWidth << ", height=" << singleBoxHeight;

	//MapRootLevel.boxes
	unique_ptr<BoundingRectangle[]> quadtreeLevel1Rectangles = make_unique<BoundingRectangle[]>(4);
	unique_ptr<BoundingRectangle[]> quadtreeLevel2Rectangles = make_unique<BoundingRectangle[]>(16);
	unique_ptr<BoundingRectangle[]> quadtreeLevel3Rectangles = make_unique<BoundingRectangle[]>(64);
	//Split the overall bounding box
	unique_ptr<BoundingRectangle[]> rectangles = make_unique<BoundingRectangle[]>(totalBoxCount);
	for (unsigned int quadtreeLevel1Y = 0; quadtreeLevel1Y < 2; quadtreeLevel1Y++) {
		for (unsigned int quadtreeLevel1X = 0; quadtreeLevel1X < 2; quadtreeLevel1X++) {
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].leftInt32 = (overallBoundingRectangle.leftInt32 + (quadtreeLevel1X * (overallBoundingRectangle.widthInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].rightInt32 = (overallBoundingRectangle.leftInt32 + ((quadtreeLevel1X + 1) * (overallBoundingRectangle.widthInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].topInt32 = (overallBoundingRectangle.topInt32 + (quadtreeLevel1Y * (overallBoundingRectangle.heightInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].bottomInt32 = (overallBoundingRectangle.topInt32 + ((quadtreeLevel1Y + 1) * (overallBoundingRectangle.heightInt32 / 2))) & 0xffffffe0;
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].calculateDoubleValuesFromInt32();
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].expandByAbsoluteValue(2000);
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&overallBoundingRectangle);
			quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].MapDataBoxBytesSizeWithoutTagAndFixed32Size -= (1 + 4); //Quadtree boxes don't have shiftToMapData
			//if (verbose) cout << endl << "Quadtree level 1 rectangle " << (((quadtreeLevel1Y * 2) + quadtreeLevel1X) + 1) << ": " << quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].left << ", " << quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].right << ", " << quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].bottom << ", " << quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].top;

			//Generate the 4 level-2 quadtree boxes
			for (unsigned int quadtreeLevel2Y = 0; quadtreeLevel2Y < 2; quadtreeLevel2Y++) {
				for (unsigned int quadtreeLevel2X = 0; quadtreeLevel2X < 2; quadtreeLevel2X++) {
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].leftInt32 = (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].leftInt32 + (quadtreeLevel2X * (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].widthInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].rightInt32 = (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].leftInt32 + ((quadtreeLevel2X + 1) * (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].widthInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].topInt32 = (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].topInt32 + (quadtreeLevel2Y * (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].heightInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].bottomInt32 = (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].topInt32 + ((quadtreeLevel2Y + 1) * (quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].heightInt32 / 2))) & 0xffffffe0;
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].calculateDoubleValuesFromInt32();
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].expandByAbsoluteValue(2000);
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&(quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X]));
					quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].MapDataBoxBytesSizeWithoutTagAndFixed32Size -= (1 + 4);
					//if (verbose) cout << endl << "\tQuadtree level 2 rectangle " << (((quadtreeLevel2Y * 2) + quadtreeLevel2X) + 1) << " (overall quadtree index " << ((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X) << "): " << quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].left << ", " << quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].right << ", " << quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].bottom << ", " << quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].top;
					//Generate the 4 level-3 quadtree boxes
					for (unsigned int quadtreeLevel3Y = 0; quadtreeLevel3Y < 2; quadtreeLevel3Y++) {
						for (unsigned int quadtreeLevel3X = 0; quadtreeLevel3X < 2; quadtreeLevel3X++) {
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].leftInt32 = (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].leftInt32 + (quadtreeLevel3X * (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].widthInt32 / 2))) & 0xffffffe0;
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].rightInt32 = (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].leftInt32 + ((quadtreeLevel3X + 1) * (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].widthInt32 / 2))) & 0xffffffe0;
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].topInt32 = (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].topInt32 + (quadtreeLevel3Y * (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].heightInt32 / 2))) & 0xffffffe0;
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].bottomInt32 = (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].topInt32 + ((quadtreeLevel3Y + 1) * (quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X].heightInt32 / 2))) & 0xffffffe0;
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].calculateDoubleValuesFromInt32();
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].expandByAbsoluteValue(2000);
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&(quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + (quadtreeLevel2Y * 2) + quadtreeLevel2X]));
							quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].MapDataBoxBytesSizeWithoutTagAndFixed32Size -= (1 + 4);
							//if (verbose) cout << endl << "\t\tQuadtree level 3 rectangle " << (((quadtreeLevel3Y * 2) + quadtreeLevel3X) + 1) << " (overall quadtree index " << ((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) << "): " << quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].left << ", " << quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].right << ", " << quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].bottom << ", " << quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].top;
							//Generate the data boxes within the level-3 quadtree
							for (unsigned int j = 0; j < splitSectionCount; j++) {
								for (unsigned int i = 0; i < splitSectionCount; i++) {
									rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].leftInt32 = (quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].leftInt32 + (i * singleBoxWidth));
									rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].rightInt32 = rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].leftInt32 + singleBoxWidth;
									rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].topInt32 = (quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].topInt32 + (j * singleBoxHeight));
									rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].bottomInt32 = (rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].topInt32 + singleBoxHeight);
									rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].calculateDoubleValuesFromInt32();
									rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].expandByAbsoluteValue(2000);
									rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i)].calculateMapDataBoxBytesSizeWithoutTagAndFixed32Size(&(quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)]));
									//cout << endl << "\t\t\tRectangle " << ((((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + ((j * splitSectionCount) + i));
								}
							}
						}
					}
				}
			}
		}
	}

	sqlite3_stmt *thread0Stmt, *thread1Stmt, *thread2Stmt, *thread3Stmt;
	thread0Stmt = nullptr;
	thread1Stmt = nullptr;
	thread2Stmt = nullptr;
	thread3Stmt = nullptr;
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread0StmtUniquePtr(thread0Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread1StmtUniquePtr(thread1Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread2StmtUniquePtr(thread2Stmt);
	unique_ptr<sqlite3_stmt, SQLite3StatementDeleter> thread3StmtUniquePtr(thread3Stmt);
	sqlite3 *thread0DBConnection, *thread1DBConnection, *thread2DBConnection, *thread3DBConnection;
	sqlite3_open_v2(databaseFilename.c_str(), &thread0DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread1DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread2DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	sqlite3_open_v2(databaseFilename.c_str(), &thread3DBConnection, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
	unique_ptr<uint64_t[]> mapDataBlockSizes = make_unique<uint64_t[]>(totalBoxCount);

	/*unique_ptr<unsigned char[]> coordinatesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> typesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> additionalTypesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);
	unique_ptr<unsigned char[]> stringNamesByteArrayTmpUniquePtr = make_unique<unsigned char[]>(1048576);*/
	array<unique_ptr<unsigned char[]>, 4> coordinatesByteArrayUniquePtrArrayForThreads;
	coordinatesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	coordinatesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	array<unique_ptr<unsigned char[]>, 4> typesByteArrayUniquePtrArrayForThreads;
	typesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	typesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	array<unique_ptr<unsigned char[]>, 4> additionalTypesByteArrayUniquePtrArrayForThreads;
	additionalTypesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	additionalTypesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	array<unique_ptr<unsigned char[]>, 4> stringNamesByteArrayUniquePtrArrayForThreads;
	stringNamesByteArrayUniquePtrArrayForThreads[0] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[1] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[2] = make_unique<unsigned char[]>(1048576);
	stringNamesByteArrayUniquePtrArrayForThreads[3] = make_unique<unsigned char[]>(1048576);

	MapDataBlockThreadInfo threadInfo[4];
	thread threadHandles[4];
	threadInfo[0].dbConnection = thread0DBConnection;
	threadInfo[0].stmt = thread0Stmt;
	threadInfo[1].dbConnection = thread1DBConnection;
	threadInfo[1].stmt = thread1Stmt;
	threadInfo[2].dbConnection = thread2DBConnection;
	threadInfo[2].stmt = thread2Stmt;
	threadInfo[3].dbConnection = thread3DBConnection;
	threadInfo[3].stmt = thread3Stmt;
	progressCompletedRectangles.store(0);
	progressTotalRectangles = totalBoxCount;
	for (int i = 0; i < 4; i++) {
		threadInfo[i].rectangles = rectangles.get();
		threadInfo[i].rectanglesCount = totalBoxCount;
		threadInfo[i].threadID = i;
		threadInfo[i].coordinatesByteArrayPtrWithinThread = coordinatesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].typesByteArrayPtrWithinThread = typesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].additionalTypesByteArrayPtrWithinThread = additionalTypesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].stringNamesByteArrayPtrWithinThread = stringNamesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].mediumZoom = mediumZoom;
		threadInfo[i].mapDataBlockSizes = mapDataBlockSizes.get();
		threadHandles[i] = thread(writeOsmAndStructure_mapIndex_levels_block_SingleSplitThreadWorker, &threadInfo[i]);
	}

	cout << endl << "Waiting for threads...";
	for (int i = 0; i < 4; i++) threadHandles[i].join();
	cout << "done";
	//for (int i = 0; i < (totalBoxCount); i++) mapDataBlockSizes[i] = getFileSize(utf8_to_wstring(string("mapDataBlock" + to_string(i) + ".tmp")).c_str());

	if (thread0Stmt != nullptr) {
		sqlite3_finalize(thread0Stmt);
		thread0Stmt = nullptr;
	}
	if (thread1Stmt != nullptr) {
		sqlite3_finalize(thread1Stmt);
		thread1Stmt = nullptr;
	}
	if (thread2Stmt != nullptr) {
		sqlite3_finalize(thread2Stmt);
		thread2Stmt = nullptr;
	}
	if (thread3Stmt != nullptr) {
		sqlite3_finalize(thread3Stmt);
		thread3Stmt = nullptr;
	}
	sqlite3_close(thread0DBConnection);
	sqlite3_close(thread1DBConnection);
	sqlite3_close(thread2DBConnection);
	sqlite3_close(thread3DBConnection);
	
	//Dynamic threading code that we can enable later
	/*sqlite3_stmt **threadStmt = new sqlite3_stmt*[threads];
	sqlite3 **threadDBConnections = new sqlite3*[threads];
	vector<unique_ptr<unsigned char[]>> coordinatesByteArrayUniquePtrArrayForThreads;
	vector<unique_ptr<unsigned char[]>> typesByteArrayUniquePtrArrayForThreads;
	vector<unique_ptr<unsigned char[]>> additionalTypesByteArrayUniquePtrArrayForThreads;
	vector<unique_ptr<unsigned char[]>> stringNamesByteArrayUniquePtrArrayForThreads;
	MapDataBlockThreadInfo *threadInfo = new MapDataBlockThreadInfo[threads];
	uintptr_t *threadHandles = new uintptr_t[threads];
	for (unsigned int i = 0; i < threads; i++) {
		threadStmt[i] = nullptr;
		sqlite3_open_v2(databaseFilename.c_str(), &(threadDBConnections[i]), SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX, NULL);
		coordinatesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));
		typesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));
		additionalTypesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));
		stringNamesByteArrayUniquePtrArrayForThreads.emplace_back(make_unique<unsigned char[]>(1048576));

		threadInfo[i].dbConnection = threadDBConnections[i];
		threadInfo[i].stmt = threadStmt[i];
		threadInfo[i].rectangles = rectangles.get();
		threadInfo[i].rectanglesCount = totalBoxCount;
		threadInfo[i].threadID = i;
		threadInfo[i].coordinatesByteArrayPtrWithinThread = coordinatesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].typesByteArrayPtrWithinThread = typesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].additionalTypesByteArrayPtrWithinThread = additionalTypesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].stringNamesByteArrayPtrWithinThread = stringNamesByteArrayUniquePtrArrayForThreads[i].get();
		threadInfo[i].mediumZoom = mediumZoom;
		threadHandles[i] = _beginthread(writeOsmAndStructure_mapIndex_levels_block_SingleSplitThreadWorker, 0, &(threadInfo[i]));
	}

	cout << endl << "Waiting for threads...";
	for (int i = 0; i < threads; i++) WaitForSingleObject((HANDLE)threadHandles[i], INFINITE);
	cout << "done";
	unique_ptr<uint64_t[]> mapDataBlockSizes = make_unique<uint64_t[]>(totalBoxCount);
	for (int i = 0; i < totalBoxCount; i++) mapDataBlockSizes[i] = getFileSize(utf8_to_wstring(string("mapDataBlock" + to_string(i) + ".tmp")).c_str());

	delete[] threadInfo;
	delete[] threadHandles;
	for (unsigned int i = 0; i < threads; i++) {
		if (threadStmt[i] != nullptr) sqlite3_finalize(threadStmt[i]);
		threadStmt[i] = nullptr;
		sqlite3_close(threadDBConnections[i]);
	}
	delete[] threadDBConnections;
	delete[] threadStmt;*/

	//MapRootLevel.boxes
	//Write these after generating the data blocks so we don't have to wait to find the offsets

	unique_ptr<uint64_t[]> quadtreeLevel1ByteSizesIncludingAllSubBoxes = make_unique<uint64_t[]>(4);
	unique_ptr<uint64_t[]> quadtreeLevel2ByteSizesIncludingAllSubBoxes = make_unique<uint64_t[]>(16);
	unique_ptr<uint64_t[]> quadtreeLevel3ByteSizesIncludingAllSubBoxes = make_unique<uint64_t[]>(64);
	uint64_t level1BoxSize, level2BoxSize, level3BoxSize;
	uint32_t rootBoxSize, boxSize;
	rootBoxSize = 1 + getVarintRequiredBytes(0) /* left */ + 1 + getVarintRequiredBytes(0) /* right */ + 1 + getVarintRequiredBytes(0) /* top */ + 1 + getVarintRequiredBytes(0) /* bottom */;
	for (int quadtreeLevel1Y = 1; quadtreeLevel1Y >= 0; quadtreeLevel1Y--) {
		for (int quadtreeLevel1X = 1; quadtreeLevel1X >= 0; quadtreeLevel1X--) {
			level1BoxSize = quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
			for (int quadtreeLevel2Y = 1; quadtreeLevel2Y >= 0; quadtreeLevel2Y--) {
				for (int quadtreeLevel2X = 1; quadtreeLevel2X >= 0; quadtreeLevel2X--) {
					level2BoxSize = quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
					for (int quadtreeLevel3Y = 1; quadtreeLevel3Y >= 0; quadtreeLevel3Y--) {
						for (int quadtreeLevel3X = 1; quadtreeLevel3X >= 0; quadtreeLevel3X--) {
							level3BoxSize = quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
							for (unsigned int i = 0; i < (splitSectionCount * splitSectionCount); i++) {
								level3BoxSize += 1 + 4 + rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
								//cout << endl << "\t\t\tRectangle size: " << rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * (splitSectionCount * splitSectionCount)) + i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
							}
							level2BoxSize += 1 + 4 + level3BoxSize;
							quadtreeLevel3ByteSizesIncludingAllSubBoxes[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)] = level3BoxSize;
							//cout << endl << "\t\tQuadtree level 3 box " << (((quadtreeLevel3Y * 2) + quadtreeLevel3X) + 1) << " (overall box " << ((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) << ") byte size without tag and fixed32 size: " << level3BoxSize;
						}
					}
					quadtreeLevel2ByteSizesIncludingAllSubBoxes[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)] = level2BoxSize;
					//cout << endl << "\tQuadtree level 2 box " << (((quadtreeLevel2Y * 2) + quadtreeLevel2X) + 1) << " (overall box " << ((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) << ") byte size without tag and fixed32 size: " << level2BoxSize;
					level1BoxSize += 1 + 4 + level2BoxSize;
				}
			}
			quadtreeLevel1ByteSizesIncludingAllSubBoxes[(quadtreeLevel1Y * 2) + quadtreeLevel1X] = level1BoxSize;
			rootBoxSize += 1 + 4 + level1BoxSize;
			//cout << endl << "Quadtree level 1 box " << (((quadtreeLevel1Y * 2) + quadtreeLevel1X) + 1) << " byte size without tag and fixed32 size: " << level1BoxSize;
		}
	}
	//cout << endl << "rootBoxSize=" << rootBoxSize << endl;
	
	//For some reason, the boxes with data have to be built in an EXACT way that includes shiftToMapData with a wiretype of 6

	//We need a root box to contain the other ones because it can't process more than one top-level box
	/*if (verbose) cout << endl << "Box sizes: ";
	uint32_t boxSize = 0;
	for (int i = 0; i < totalBoxCount; i++) {
		if (verbose) cout << rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		boxSize += 1 + 4 + rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		if (verbose && i < totalBoxCount - 1) cout << ", ";
	}*/
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMaxZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(mediumZoom ? 14 : 26);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kMinZoomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(mediumZoom ? 5 : 15);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kLeftFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.leftInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kRightFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.rightInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kTopFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.topInt32);
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBottomFieldNumber << 3));
	mapRootLevelTempCos.WriteVarint32(overallBoundingRectangle.bottomInt32);
	//Root box
	mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBoxesFieldNumber << 3) | 6);
	//cout << endl << "Root box size: " << boxSize;
	rootBoxSize = swap_endian(rootBoxSize);
	mapRootLevelTempCos.WriteRaw(&rootBoxSize, 4);
	//boxSize = swap_endian(boxSize);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);
	mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
	mapRootLevelTempCos.WriteVarint32(0);

	unsigned int boxesWithinLevel3Quadtree = (splitSectionCount * splitSectionCount);
	uint32_t shiftToMapData = 0;
	for (unsigned int quadtreeLevel1Y = 0; quadtreeLevel1Y < 2; quadtreeLevel1Y++) {
		for (unsigned int quadtreeLevel1X = 0; quadtreeLevel1X < 2; quadtreeLevel1X++) {
			//Top-level quadtree boxes
			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
			boxSize = quadtreeLevel1ByteSizesIncludingAllSubBoxes[(quadtreeLevel1Y * 2) + quadtreeLevel1X] /*- (1 + 4)*/;
			//Add the 4 level-2 quadtree box sizes and their sub-boxes
			/*for (int i = 0; i < 4; i++) {
				//Level-2 quadtree box
				boxSize += 1 + 4 + quadtreeLevel2ByteSizes[(((y * 2) + x) * 4) + i];

				//Sub-boxes
				for (int j = 0; j < (splitSectionCount * splitSectionCount); j++) boxSize += 1 + 4 + rectangles[(((((y * 2) + x) * 4) + i) * (splitSectionCount * splitSectionCount)) + j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
			}*/
			boxSize = swap_endian(boxSize);
			mapRootLevelTempCos.WriteRaw(&boxSize, 4);
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].leftInt32) - ((int64_t)overallBoundingRectangle.leftInt32)));
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].rightInt32) - ((int64_t)overallBoundingRectangle.rightInt32)));
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].topInt32) - ((int64_t)overallBoundingRectangle.topInt32)));
			mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
			mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].bottomInt32) - ((int64_t)overallBoundingRectangle.bottomInt32)));
			for (unsigned int quadtreeLevel2Y = 0; quadtreeLevel2Y < 2; quadtreeLevel2Y++) {
				for (unsigned int quadtreeLevel2X = 0; quadtreeLevel2X < 2; quadtreeLevel2X++) {
					//Level-2 quadtree boxes
					mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
					boxSize = quadtreeLevel2ByteSizesIncludingAllSubBoxes[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)] /*- (1 + 4)*/;
					//for (int j = 0; j < (splitSectionCount * splitSectionCount); j++) boxSize += 1 + 4 + rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * (splitSectionCount * splitSectionCount)) + j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
					boxSize = swap_endian(boxSize);
					mapRootLevelTempCos.WriteRaw(&boxSize, 4);
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].leftInt32) - ((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].leftInt32)));
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].rightInt32) - ((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].rightInt32)));
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].topInt32) - ((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].topInt32)));
					mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
					mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].bottomInt32) - ((int64_t)quadtreeLevel1Rectangles[(quadtreeLevel1Y * 2) + quadtreeLevel1X].bottomInt32)));
					for (unsigned int quadtreeLevel3Y = 0; quadtreeLevel3Y < 2; quadtreeLevel3Y++) {
						for (unsigned int quadtreeLevel3X = 0; quadtreeLevel3X < 2; quadtreeLevel3X++) {
							//Level-3 quadtree boxes
							mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
							boxSize = quadtreeLevel3ByteSizesIncludingAllSubBoxes[((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)] /*- (1 + 4)*/;
							//for (int j = 0; j < (splitSectionCount * splitSectionCount); j++) boxSize += 1 + 4 + rectangles[(((((y * 2) + x) * 4) + ((y2 * 2) + x2)) * (splitSectionCount * splitSectionCount)) + j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
							boxSize = swap_endian(boxSize);
							mapRootLevelTempCos.WriteRaw(&boxSize, 4);
							mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
							mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].leftInt32) - ((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].leftInt32)));
							mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
							mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].rightInt32) - ((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].rightInt32)));
							mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
							mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].topInt32) - ((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].topInt32)));
							mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
							mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].bottomInt32) - ((int64_t)quadtreeLevel2Rectangles[(((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)].bottomInt32)));
							for (int j = 0; j < boxesWithinLevel3Quadtree; j++) {
								mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
								boxSize = rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * boxesWithinLevel3Quadtree) + j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
								boxSize = swap_endian(boxSize);
								mapRootLevelTempCos.WriteRaw(&boxSize, 4);
								mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
								mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * boxesWithinLevel3Quadtree) + j].leftInt32) - ((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].leftInt32)));
								mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
								mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * boxesWithinLevel3Quadtree) + j].rightInt32) - ((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].rightInt32)));
								mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
								mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * boxesWithinLevel3Quadtree) + j].topInt32) - ((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].topInt32)));
								mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
								mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * boxesWithinLevel3Quadtree) + j].bottomInt32) - ((int64_t)quadtreeLevel3Rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)].bottomInt32)));
								//shiftToMapData
								//Add the sizes of the future sub-boxes in this level 3 quadtree block + the other level 2 quadtree blocks + the other level 1 quadtree blocks + the sizes of the data blocks before the current one
								shiftToMapData = 0;
								//Add the future blocks within the current level 3 quadtree
								for (int k = j; k < boxesWithinLevel3Quadtree; k++) {
									//shiftToMapData += (k > j ? (1 + 4) : 0) /* Don't add our (the current sub-box's) tag and fixed32 size since we're starting from the MapDatBox.left tag */ + rectangles[(((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * boxesWithinLevel3Quadtree) + /*j*/k].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
									shiftToMapData += (k > j ? (1 + 4) : 0) /* Don't add our (the current sub-box's) tag and fixed32 size since we're starting from the MapDatBox.left tag */ + rectangles[(((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * boxesWithinLevel3Quadtree) + /*j*/k].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
								}
								//Add the future level 3 quadtree blocks
								for (unsigned int k = (((quadtreeLevel3Y * 2) + quadtreeLevel3X) + 1); k < 4; k++) {
									shiftToMapData += 1 + 4 + quadtreeLevel3ByteSizesIncludingAllSubBoxes[k];
								}
								//Add the future level 2 quadtree blocks
								for (unsigned int k = (((quadtreeLevel2Y * 2) + quadtreeLevel2X) + 1); k < 4; k++) {
									shiftToMapData += 1 + 4 + quadtreeLevel2ByteSizesIncludingAllSubBoxes[k];
								}
								//Add the future level 1 quadtree blocks
								for (unsigned int k = (((quadtreeLevel1Y * 2) + quadtreeLevel1X) + 1); k < 4; k++) {
									shiftToMapData += 1 + 4 + quadtreeLevel1ByteSizesIncludingAllSubBoxes[k];
								}
								//Add the future MapDataBlock sizes
								for (unsigned int k = 0; k < ((((((((quadtreeLevel1Y * 2) + quadtreeLevel1X) * 4) + ((quadtreeLevel2Y * 2) + quadtreeLevel2X)) * 4) + ((quadtreeLevel3Y * 2) + quadtreeLevel3X)) * boxesWithinLevel3Quadtree) + j); k++) {
									shiftToMapData += 1 + getVarintRequiredBytes(mapDataBlockSizes[k]) + mapDataBlockSizes[k];
								}
								shiftToMapData++;
								mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kShiftToMapDataFieldNumber << 3) | 6);
								shiftToMapData = swap_endian(shiftToMapData);
								mapRootLevelTempCos.WriteRaw(&shiftToMapData, 4);
							}
						}
					}
				}
			}
		}
	}

	/*This should be
		[current boxSize_without_tag_and_fixed32size] +
		[all future boxes with tag and fixed32 size] +
		[sizes of any undesired MapDataBlocks + tag and varint size] +
		[desired box's tag]
	so the offset is from MapDataBox.left_tag to MapDataBlock.varint_size*/
	/*uint32_t shiftToMapData = 0;
	for (int i = 0; i < totalBoxCount; i++) {
		shiftToMapData = rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		//Add the future MapDataBoxes
		for (int j = i + 1; j < totalBoxCount; j++) {
			shiftToMapData += 1 + 4 + rectangles[j].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		}
		//Add the future MapDataBlocks
		for (int j = 0; j < i; j++) {
			shiftToMapData += 1 + getVarintRequiredBytes(mapDataBlockSizes[j]) + mapDataBlockSizes[j];
		}
		shiftToMapData++; //Skip the MapDataBlock tag

		mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBoxesFieldNumber << 3) | 6);
		boxSize = rectangles[i].MapDataBoxBytesSizeWithoutTagAndFixed32Size;
		boxSize = swap_endian(boxSize);
		mapRootLevelTempCos.WriteRaw(&boxSize, 4);
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kLeftFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].leftInt32) - ((int64_t)overallBoundingRectangle.leftInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kRightFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].rightInt32) - ((int64_t)overallBoundingRectangle.rightInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kTopFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].topInt32) - ((int64_t)overallBoundingRectangle.topInt32)));
		mapRootLevelTempCos.WriteTag(OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kBottomFieldNumber << 3);
		mapRootLevelTempCos.WriteVarint32(getSInt32FromInt32(((int64_t)rectangles[i].bottomInt32) - ((int64_t)overallBoundingRectangle.bottomInt32)));
		mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapDataBox::kShiftToMapDataFieldNumber << 3) | 6);
		shiftToMapData = swap_endian(shiftToMapData);
		mapRootLevelTempCos.WriteRaw(&shiftToMapData, 4);
	}*/

	//Write the MapDataBlocks
	//We should delete the temp files as we copy them to save space
	{
		ifstream thread1TempFile("thread0_" + to_string(pid) + ".tmp", ios::binary);
		ifstream thread2TempFile("thread1_" + to_string(pid) + ".tmp", ios::binary);
		ifstream thread3TempFile("thread2_" + to_string(pid) + ".tmp", ios::binary);
		ifstream thread4TempFile("thread3_" + to_string(pid) + ".tmp", ios::binary);
		uint32_t mapDataBlockSize;
		for (int i = 0; i < totalBoxCount / 4; i++) {
			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread1TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread1TempFile, mapDataBlockSize);

			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread2TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread2TempFile, mapDataBlockSize);

			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread3TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread3TempFile, mapDataBlockSize);

			mapRootLevelTempCos.WriteTag((OsmAnd::OBF::OsmAndMapIndex::MapRootLevel::kBlocksFieldNumber << 3) | 2);
			thread4TempFile.read((char*)&mapDataBlockSize, 4);
			mapDataBlockSize = swap_endian(mapDataBlockSize);
			mapRootLevelTempCos.WriteVarint32(mapDataBlockSize);
			copyRawInputStreamIntoCodedOutputStream(mapRootLevelTempCos, &thread4TempFile, mapDataBlockSize);
		}
	}
	if (!shouldKeepTempFiles) {
		remove(string("thread0_" + to_string(pid) + ".tmp").c_str());
		remove(string("thread1_" + to_string(pid) + ".tmp").c_str());
		remove(string("thread2_" + to_string(pid) + ".tmp").c_str());
		remove(string("thread3_" + to_string(pid) + ".tmp").c_str());
	}
}

void writeOsmAndStructure_mapIndex_levels_block_SingleSplitThreadWorker(void *param) {
	MapDataBlockThreadInfo *ptr = (MapDataBlockThreadInfo*)param;
	uint64_t *mapDataBlockSizes = ptr->mapDataBlockSizes;
	sqlite3_stmt *wayNodeStmt;
	sqlite3_stmt *wayTagStmt;
	sqlite3_stmt *tempStmt;
	sqlite3_stmt *waysWithinRectangleStmt;
	char *errorMessage = 0;
	//Get a list of all the way ID's
	//Use the first node to see if the way should be included in the current block
	sqlite3_exec(ptr->dbConnection, string("PRAGMA cache_size = -" + to_string(sqliteCacheSizeMiBPerThread << 10) + ";").c_str(), NULL, 0, &errorMessage);
	sqlite3_exec(ptr->dbConnection, string("PRAGMA mmap_size = " + to_string(sqliteMMAPSizeMiBPerThread << 20) + ";").c_str(), NULL, 0, &errorMessage);
	sqlite3_exec(ptr->dbConnection, "PRAGMA journal_mode=WAL;", NULL, 0, &errorMessage);
	sqlite3_exec(ptr->dbConnection, "CREATE TEMP TABLE waysWithinRectangle (way_id INTEGER PRIMARY KEY);", NULL, 0, &errorMessage);
	if (!ptr->mediumZoom) {
		sqlite3_prepare_v2(ptr->dbConnection, "INSERT INTO waysWithinRectangle (way_id) SELECT w.way_id FROM way_nodes w INNER JOIN rtree_node r ON r.node_id = w.node_id WHERE w.node_order = 1 AND r.max_lat >= :bottom AND r.min_lat <= :top AND r.max_lon >= :left AND r.min_lon <= :right;", -1, &waysWithinRectangleStmt, 0);
	} else {
		sqlite3_prepare_v2(ptr->dbConnection, "INSERT INTO waysWithinRectangle (way_id) SELECT w.way_id FROM way_nodes w INNER JOIN rtree_node r ON r.node_id = w.node_id WHERE w.node_order = 1 AND r.max_lat >= :bottom AND r.min_lat <= :top AND r.max_lon >= :left AND r.min_lon <= :right AND EXISTS (SELECT 1 FROM way_tags q3 WHERE q3.way_id = w.way_id AND ((q3.key = 'highway' AND q3.value IN ('motorway', 'motorway_link', 'motorway_junction', 'primary', 'primary_link', 'secondary', 'secondary_link', 'tertiary', 'tertiary_link', 'trunk', 'trunk_link')) OR (q3.key IN ('lanes', 'lanes:forward', 'lanes:backward', 'hgv', 'maxspeed', 'oneway', 'destination', 'motorway_link'))));", -1, &waysWithinRectangleStmt, 0);
	}
	sqlite3_prepare_v2(ptr->dbConnection, "select w.way_id, w.node_id, n.lat, n.lon from way_nodes w inner join nodes n on n.node_id=w.node_id where w.way_id in waysWithinRectangle order by w.way_id, w.node_order asc;", -1, &wayNodeStmt, 0);
	string wayTagsQuery = "select w1.way_id, t.key, t.value, case when t.key in (%HIGH_PRIORITY_WHITELIST%) then 0 when t.key in (%HUMAN_READABLE_WHITELIST%) then 2 else 1 end as tagType from way_tags t inner join waysWithinRectangle w1 on w1.way_id=t.way_id where %MACHINE_READABLE_BLACKLIST% group by w1.way_id, t.key, t.value order by w1.way_id asc, tagType asc, t.key asc, t.value asc;";
	wayTagsQuery.replace(wayTagsQuery.find("%HIGH_PRIORITY_WHITELIST%"), 25, TAG_KEYS_HIGH_PRIORITY_WHITELIST);
	wayTagsQuery.replace(wayTagsQuery.find("%HUMAN_READABLE_WHITELIST%"), 26, TAG_KEYS_HUMAN_READABLE_WHITELIST);
	wayTagsQuery.replace(wayTagsQuery.find("%MACHINE_READABLE_BLACKLIST%"), 28, TAG_KEYS_MACHINE_READABLE_BLACKLIST);
	//if (ptr->threadID == 0) cout << endl << "[Thread " << ptr->threadID << "] " << wayTagsQuery << endl;
	sqlite3_prepare_v2(ptr->dbConnection, wayTagsQuery.c_str(), -1, &wayTagStmt, 0);
	//It's better to save the MapDataBlocks to a larger temp file per-thread than separate ones because the "Size on disk" can be huge for a lot of small files
	ofstream threadTempFile(string("thread" + to_string(ptr->threadID) + "_" + to_string(pid) + ".tmp"), ios::binary);
	google::protobuf::io::OstreamOutputStream threadTempOstream(&threadTempFile);
	google::protobuf::io::CodedOutputStream threadBlockCos(&threadTempOstream);
	uint32_t fileSizeBE = 0;
	for (int i = 0; i < ptr->rectanglesCount; i++) {
		int blockIdx = (i * 4) + ptr->threadID;
		if (blockIdx >= ptr->rectanglesCount) break;

		sqlite3_exec(ptr->dbConnection, "DELETE FROM waysWithinRectangle;", NULL, 0, &errorMessage);
		sqlite3_reset(waysWithinRectangleStmt);
		//cout << endl << "[Thread " << ptr->threadID << "] Line 2171" << endl;
		sqlite3_clear_bindings(waysWithinRectangleStmt);
		sqlite3_bind_double(waysWithinRectangleStmt, sqlite3_bind_parameter_index(waysWithinRectangleStmt, ":left"), ptr->rectangles[blockIdx].left);
		sqlite3_bind_double(waysWithinRectangleStmt, sqlite3_bind_parameter_index(waysWithinRectangleStmt, ":right"), ptr->rectangles[blockIdx].right);
		sqlite3_bind_double(waysWithinRectangleStmt, sqlite3_bind_parameter_index(waysWithinRectangleStmt, ":bottom"), ptr->rectangles[blockIdx].bottom);
		sqlite3_bind_double(waysWithinRectangleStmt, sqlite3_bind_parameter_index(waysWithinRectangleStmt, ":top"), ptr->rectangles[blockIdx].top);
		if (sqlite3_step(waysWithinRectangleStmt) != SQLITE_DONE) cout << endl << "Error while generating the temp table: " << sqlite3_errmsg(ptr->dbConnection) << endl;
		
		#if defined(_WIN32)
			PostMessage(hwndMainWin, WM_USER_REDRAW, NULL, NULL);
		#endif
		writeOsmAndStructure_mapIndex_levels_block(string("mapDataBlock" + to_string(blockIdx) + "_" + to_string(pid) + ".tmp"), &ptr->rectangles[blockIdx], blockIdx, ptr->dbConnection, ptr->stmt, wayNodeStmt, wayTagStmt, ptr->threadID, ptr->coordinatesByteArrayPtrWithinThread, ptr->typesByteArrayPtrWithinThread, ptr->additionalTypesByteArrayPtrWithinThread, ptr->stringNamesByteArrayPtrWithinThread, ptr->mediumZoom);
		progressCompletedRectangles.fetch_add(1, memory_order_relaxed);
		#if defined(_WIN32)
			PostMessage(hwndMainWin, WM_USER_REDRAW, NULL, NULL);
		#endif
		mapDataBlockSizes[blockIdx] = getFileSize(string("mapDataBlock" + to_string(blockIdx) + "_" + to_string(pid) + ".tmp"));
		fileSizeBE = mapDataBlockSizes[blockIdx];
		fileSizeBE = swap_endian(fileSizeBE);
		threadBlockCos.WriteRaw(&fileSizeBE, 4);
		copyRawFileIntoCodedOutputStream(threadBlockCos, "mapDataBlock" + to_string(blockIdx) + "_" + to_string(pid) + ".tmp", mapDataBlockSizes[blockIdx]);
		if (!shouldKeepTempFiles) remove(string("mapDataBlock" + to_string(blockIdx) + "_" + to_string(pid) + ".tmp").c_str());
	}
	sqlite3_exec(ptr->dbConnection, "DROP TABLE IF EXISTS temp.waysWithinRectangle;", NULL, 0, &errorMessage);

	sqlite3_finalize(waysWithinRectangleStmt);
	sqlite3_finalize(wayTagStmt);
	sqlite3_finalize(wayNodeStmt);
}

void writeOsmAndStructure_mapIndex_levels_block(string tempFilename, BoundingRectangle *rectangle, unsigned int blockIdx, sqlite3 *dbConnection, sqlite3_stmt *stmt, sqlite3_stmt *wayNodeStmt, sqlite3_stmt *wayTagStmt, int threadID, unsigned char *coordinatesByteArrayPtrWithinThread, unsigned char *typesByteArrayPtrWithinThread, unsigned char *additionalTypesByteArrayPtrWithinThread, unsigned char *stringNamesByteArrayPtrWithinThread, bool mediumZoom) {
	remove(tempFilename.c_str());
	ofstream mapDataBlockTemp(tempFilename, ios::binary);
	google::protobuf::io::OstreamOutputStream mapDataBlockTempOstream(&mapDataBlockTemp);
	google::protobuf::io::CodedOutputStream mapDataBlockCos(&mapDataBlockTempOstream);
	int wayNodeRC = sqlite3_step(wayNodeStmt);
	int wayTagStmtRC = sqlite3_step(wayTagStmt);
	
	if (shouldShowGUI) {
		progressBitmapPtr[(blockIdx * 4)] = 0xe0;
		progressBitmapPtr[(blockIdx * 4) + 1] = 0xe0;
		progressBitmapPtr[(blockIdx * 4) + 2] = 0;
		progressBitmapPtr[(blockIdx * 4) + 3] = 255;
	}

	bool shouldSkipBlock = false;
	int rc = sqlite3_prepare_v2(dbConnection, "select sum(c) from (select exists(select * from rtree_node q1 inner join node_tags q2 on q2.node_id=q1.node_id where (max_lat >= :bottom and min_lat <= :top) and (max_lon >= :left and min_lon <= :right)) as c union all select exists(select * from rtree_node q1 inner join way_nodes q3 on q3.node_id=q1.node_id where q3.node_order=1 and (max_lat >= :bottom and min_lat <= :top) and (max_lon >= :left and min_lon <= :right)) as c)", -1, &stmt, 0);
	sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":left"), rectangle->left);
	sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":right"), rectangle->right);
	sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":bottom"), rectangle->bottom);
	sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":top"), rectangle->top);
	if ((rc = sqlite3_step(stmt)) != SQLITE_ROW || sqlite3_column_int(stmt, 0) == 0) {
		if (verbose) cout << endl << "Skipping block";
		shouldSkipBlock = true;
		if (shouldShowGUI) {
			progressBitmapPtr[(blockIdx * 4)] = 0xc0;
			progressBitmapPtr[(blockIdx * 4) + 1] = 0xc0;
			progressBitmapPtr[(blockIdx * 4) + 2] = 0xc0;
			progressBitmapPtr[(blockIdx * 4) + 3] = 255;
		}
	}
	sqlite3_finalize(stmt);
	stmt = nullptr;

	uint32_t i = 0;
	uint32_t uniqueValueCount = 0;
	uint64_t uniqueValuesByteCount = 0;
	string value = "";
	unordered_map<string, uint32_t> stringTable;
	uint64_t medianUniqueID = 0;

	if (!shouldSkipBlock) {
		//Get all of the way and node tag values, sorted by frequency descending, and load them in memory
		//Even for the entire southeast US, that is only around 70 MB so it should be safe to store it in an unordered_map
		//This might help with cache locality on the reader, and definitely minimizes the sizes of the varint indices
		rc = sqlite3_prepare_v2(dbConnection, QUERY_GET_UNIQUE_WAY_AND_NODE_TAG_VALUES_BLACKLIST, -1, &stmt, 0);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":left"), rectangle->left);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":right"), rectangle->right);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":bottom"), rectangle->bottom);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":top"), rectangle->top);
		if (verbose) cout << endl << endl << "Bottom,top,left,right=" << rectangle->bottom << ", " << rectangle->top << ", " << rectangle->left << ", " << rectangle->right;
		if (rc != SQLITE_OK) {
			cout << endl << "Error while creating the MapDataBlock unique values prepared statement";
		}

		//We need the StringTable file objects to go out of scope so they get closed properly, and it's more efficient to write that now while we're loading the values into memory
		{
			remove(string("mapDataBlockStringTable_" + tempFilename).c_str());
			ofstream mapDataBlockStringTableTemp(string("mapDataBlockStringTable_" + tempFilename).c_str(), ios::binary);
			google::protobuf::io::OstreamOutputStream mapDataBlockStringTableOstream(&mapDataBlockStringTableTemp);
			google::protobuf::io::CodedOutputStream mapDataBlockStringTableCos(&mapDataBlockStringTableOstream);
			while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
				if (i == 0) {
					uniqueValueCount = sqlite3_column_int(stmt, 3);
					stringTable.reserve(uniqueValueCount);
					if (verbose) cout << endl << "Found " << uniqueValueCount << " unique human-readable tag value" << (uniqueValueCount != 1 ? "s" : "");
				}
				value = string((char*)sqlite3_column_text(stmt, 0));
				mapDataBlockStringTableCos.WriteTag((OsmAnd::OBF::StringTable::kSFieldNumber << 3) | 2);
				mapDataBlockStringTableCos.WriteVarint32(value.length());
				mapDataBlockStringTableCos.WriteString(value);
				uniqueValuesByteCount += value.length() + getVarintRequiredBytes(value.length()) + 1;
				stringTable.emplace(value, i);
				//cout << endl << i << " " << value;
				i++;
			}
		}
		sqlite3_finalize(stmt);
		stmt = nullptr;
		if (verbose) cout << " (" << uniqueValuesByteCount << " bytes)";

		//Get the median of the unique ID's from way_tags (faster than way_nodes) and nodes so the delta ID values will be as small as possible
		//We want the median of the unique values because the median of all the values will skew toward ways with more nodes
		rc = sqlite3_prepare_v2(dbConnection, QUERY_GET_MEDIAN_UNIQUE_ID, -1, &stmt, 0);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":left"), rectangle->left);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":right"), rectangle->right);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":bottom"), rectangle->bottom);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":top"), rectangle->top);
		if (rc != SQLITE_OK) {
			cout << endl << "Error while getting the median unique ID";
		}
		sqlite3_step(stmt);
		medianUniqueID = llround(sqlite3_column_double(stmt, 0));
		sqlite3_finalize(stmt);
		stmt = nullptr;
		if (verbose) cout << endl << "Median unique ID: " << medianUniqueID;
		//Query to get actual bounding box that includes ways with the first node within the original bounding box
		/*rc = sqlite3_prepare_v2(dbConnection, "select min(q3.min_lon) as actual_left, max(q3.max_lon) as actual_right, min(q3.min_lat) as actual_bottom, max(q3.max_lat) as actual_top from way_nodes q1 inner join rtree_node q2 on q2.node_id=q1.node_id inner join rtree_way q3 on q3.way_id=q1.way_id where q1.node_order=1 and (q2.max_lat >= :bottom and q2.min_lat <= :top) and (q2.max_lon >= :left and q2.min_lon <= :right);", -1, &stmt, 0);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":left"), rectangle->left);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":right"), rectangle->right);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":bottom"), rectangle->bottom);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":top"), rectangle->top);
		if (rc != SQLITE_OK) {
			cout << endl << "Error while getting the actual bounding box";
		}
		sqlite3_step(stmt);
		oldLeft = rectangle->left;
		oldRight = rectangle->right;
		oldBottom = rectangle->bottom;
		oldTop = rectangle->top;
		if (sqlite3_column_double(stmt, 0) < rectangle->left) rectangle->left = sqlite3_column_double(stmt, 0);
		if (sqlite3_column_double(stmt, 1) > rectangle->right) rectangle->right = sqlite3_column_double(stmt, 1);
		if (sqlite3_column_double(stmt, 2) < rectangle->bottom) rectangle->bottom = sqlite3_column_double(stmt, 2);
		if (sqlite3_column_double(stmt, 3) > rectangle->top) rectangle->top = sqlite3_column_double(stmt, 3);
		rectangle->calculateInt32ValuesFromDouble();
		//rectangle->expandByAbsoluteValue(8000);
		sqlite3_finalize(stmt);
		stmt = nullptr;*/
	}
	
	//MapDataBlock.baseId
	mapDataBlockCos.WriteTag((OsmAnd::OBF::MapDataBlock::kBaseIdFieldNumber << 3));
	mapDataBlockCos.WriteVarint64((medianUniqueID << 7) /*(| 3*/);
	if (!shouldSkipBlock) {
		//MapDataBlock.dataObjects
		OsmAnd::OBF::MapData mapData;
		uint64_t way_id, node_id, firstNodeID, node_order, index_within_way;
		way_id = 0;
		int64_t deltaLat, deltaLon;
		int64_t lat, lon;
		unsigned char *coordinatesByteArrayPtr = coordinatesByteArrayPtrWithinThread;
		unsigned char *typesByteArrayPtr = typesByteArrayPtrWithinThread;
		unsigned char *additionalTypesByteArrayPtr = additionalTypesByteArrayPtrWithinThread;
		unsigned char *stringNamesByteArrayPtr = stringNamesByteArrayPtrWithinThread;
		uint32_t coordinatesByteLength = 0;
		uint32_t coordinatesCount = 0;
		//uint32_t nodesWithinWay = 0;
		bool isArea = false;
		uint64_t prevLatInt32, prevLonInt32; //The previous latitude and longitude with the cumulative rounding errors

		//Ways
		uint64_t wayIDIndex = 0;
		vector<uint64_t> nodeIDVector;
		vector<uint64_t> latVector;
		vector<uint64_t> lonVector;
		nodeIDVector.reserve(2048); //Pre-allocate memory for up to 2048 elements. As of 2026/07/06, the longest way in the southeast US data has 1978 nodes
		latVector.reserve(2048);
		lonVector.reserve(2048);
		bool shouldStopIteratingOverWays = false;
		while (!shouldStopIteratingOverWays) {
			/*if (verbose) {
				if (wayIDIndex == 0) cout << endl;
				if ((wayIDs.size() < 1000 || wayIDIndex % 99 == 0)) {
					cout << "\rWriting way " << (wayIDIndex + 1) << "/" << wayIDs.size() << " (" << ((wayIDIndex + 1) * 100.0) / wayIDs.size() << "%)";
				}
			}*/
			coordinatesByteLength = 0;
			coordinatesCount = 0;
			coordinatesByteArrayPtr = coordinatesByteArrayPtrWithinThread;
			typesByteArrayPtr = typesByteArrayPtrWithinThread;
			additionalTypesByteArrayPtr = additionalTypesByteArrayPtrWithinThread;
			isArea = false;
			
			if (wayNodeRC == SQLITE_ROW) {
				//nodesWithinWay = sqlite3_column_int64(wayNodeStmt, 6);
				node_id = sqlite3_column_int64(wayNodeStmt, 1);
				firstNodeID = node_id;
				way_id = sqlite3_column_int64(wayNodeStmt, 0);
				do {
					nodeIDVector.emplace_back(sqlite3_column_int64(wayNodeStmt, 1));
					latVector.emplace_back(latitudeToInt32(sqlite3_column_double(wayNodeStmt, 2), 21));
					lonVector.emplace_back(longitudeToInt32(sqlite3_column_double(wayNodeStmt, 3), 21));
				} while (((wayNodeRC = sqlite3_step(wayNodeStmt)) == SQLITE_ROW) && (sqlite3_column_int64(wayNodeStmt, 0) /* way_id */ == way_id));
			}
			//We have to check this again instead of using ELSE because this could have changed in the DO WHILE loop test condition and stopped it
			if (wayNodeRC != SQLITE_ROW) shouldStopIteratingOverWays = true;

			if (mediumZoom) VWSimplify(&nodeIDVector, &latVector, &lonVector, 40000000);

			vector<uint64_t>::iterator nodeIDVectorIter = nodeIDVector.begin();
			vector<uint64_t>::iterator latVectorIter = latVector.begin();
			vector<uint64_t>::iterator lonVectorIter = lonVector.begin();
			node_order = 0;
			index_within_way = 0;
			for (int i = 0; i < nodeIDVector.size(); i++) {
				node_id = *(nodeIDVectorIter++);
				node_order++;
				lat = *(latVectorIter++);
				lon = *(lonVectorIter++);
				index_within_way++;

				if (index_within_way == 1) {
					//nodesWithinWay = sqlite3_column_int64(stmt, 6);
					firstNodeID = node_id;

					//The delta is based on the top-left point of the bounding box
					deltaLat = ((int64_t)lat) - ((int64_t)rectangle->topInt32);
					prevLatInt32 = lat;
					deltaLon = ((int64_t)lon) - ((int64_t)rectangle->leftInt32);
					prevLonInt32 = lon;
				} else {
					//The delta is based on the previous node
					//Keep track of all the previous deltas by adding the rounded ones so we can base the current one on that instead of the accurate values
					deltaLat = ((int64_t)lat) - ((int64_t)prevLatInt32);
					deltaLon = ((int64_t)lon) - ((int64_t)prevLonInt32);
					prevLatInt32 = lat;
					prevLonInt32 = lon;
				}
				//cout << endl << "way deltaLat=" << deltaLat << " (lower 5 bits=" << (deltaLat & 0x1f) << "), deltaLon=" << deltaLon << " (lower 5 bits=" << (deltaLon & 0x1f) << ")" << endl;
				//If this is the last node in the way, see if adding or subtracting 32 makes the end node coordinates more accurate
				if (index_within_way == latVector.size()) {
					isArea = firstNodeID == node_id;
				}
				//cout << endl << "deltaX=" << ((deltaLon >> 5) << 5) << ", deltaY=" << ((deltaLat >> 5) << 5);
				//Write the delta values as sint32
				deltaLat >>= 5;
				deltaLon >>= 5;
				uint64_t sint32;
				//X (longitude)
				coordinatesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(getSInt32FromInt32(deltaLon), coordinatesByteArrayPtr);
				//Y (latitude)
				coordinatesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(getSInt32FromInt32(deltaLat), coordinatesByteArrayPtr);
			}
			nodeIDVector.clear();
			latVector.clear();
			lonVector.clear();

			//MapData.coordinates
			/*if (isArea) {
				mapData.set_areacoordinates(reinterpret_cast<const char*>(coordinatesByteArrayPtrWithinThread), (coordinatesByteArrayPtr - coordinatesByteArrayPtrWithinThread));
			} else {*/
				mapData.set_coordinates(reinterpret_cast<const char*>(coordinatesByteArrayPtrWithinThread), (coordinatesByteArrayPtr - coordinatesByteArrayPtrWithinThread));
			//}

			//Write the tags

			//cout << endl << wayTagsQuery;
			//cout << endl << "Way tags query " << wayTagsQuery;
			//string tag = "";
			string key = "";
			string value = "";
			typesByteArrayPtr = typesByteArrayPtrWithinThread;
			additionalTypesByteArrayPtr = additionalTypesByteArrayPtrWithinThread;
			stringNamesByteArrayPtr = stringNamesByteArrayPtrWithinThread;
			bool highPriority = false;
			bool finishedWritingHighPriorityTags = false;
			bool finishedWritingLowPriorityTags = false;
			while (wayTagStmtRC == SQLITE_ROW) {
				if (sqlite3_column_int64(wayTagStmt, 0) != way_id) break;
				//tag = (char*)sqlite3_column_text(res, 0);
				key = (char*)sqlite3_column_text(wayTagStmt, 1);
				value = (char*)sqlite3_column_text(wayTagStmt, 2);
				//cout << endl << "tag=\"" << tag << "\"";

				switch (sqlite3_column_int64(wayTagStmt, 3) /* tagType */) {
					case 0: //high_priority machine-readable tags for the "types" array
						{
							//MapData.types
							//These are the high-priority machine-readable tags
							typesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(keyMap[key + "=" + value] + 1, typesByteArrayPtr);
							//cout << endl << "Adding high-priority tag " << key << "=" << value;
							break;
						}
					case 1: //low_priority machine-readable tags for the "additionalTypes" array
						{
							additionalTypesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(keyMap[key + "=" + value] + 1, additionalTypesByteArrayPtr);
							//cout << endl << "Adding low-priority tag " << key << "=" << value;
							break;
						}
					case 2: //human-readable tags for the "stringNames" array
						{
							//The stringNames array requires pairs instead of single values
							//The 1st value points to the MapEncodingRule
							//The 2nd value points to the value in the StringTable
							stringNamesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(keyMap[key + "="] + 1, stringNamesByteArrayPtr);
							stringNamesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(stringTable[value], stringNamesByteArrayPtr);
							//cout << endl << "Adding low-priority tag " << tag;
							break;
						}
				}

				wayTagStmtRC = sqlite3_step(wayTagStmt);
			}
			/*if ((typesByteArrayPtr - typesByteArrayPtrWithinThread) > 0)*/ mapData.set_types(reinterpret_cast<const char*>(typesByteArrayPtrWithinThread), (typesByteArrayPtr - typesByteArrayPtrWithinThread));
			/*if ((additionalTypesByteArrayPtr - additionalTypesByteArrayPtrWithinThread) > 0)*/ mapData.set_additionaltypes(reinterpret_cast<const char*>(additionalTypesByteArrayPtrWithinThread), (additionalTypesByteArrayPtr - additionalTypesByteArrayPtrWithinThread));
			/*if ((stringNamesByteArrayPtr - stringNamesByteArrayPtrWithinThread) > 0)*/ mapData.set_stringnames(reinterpret_cast<const char*>(stringNamesByteArrayPtrWithinThread), (stringNamesByteArrayPtr - stringNamesByteArrayPtrWithinThread));

			//MapData.additionalTypes
			//These are the low-priority machine-readable types
			//The delta ID is relative to the osmand_id, not the original_id
			mapData.set_id(((((int64_t)way_id) - ((int64_t)medianUniqueID)) << 7) | 3 /* The lower 2 bits might be for ways */);

			mapDataBlockCos.WriteTag((OsmAnd::OBF::MapDataBlock::kDataObjectsFieldNumber << 3) | 2);
			mapDataBlockCos.WriteVarint32(mapData.ByteSizeLong());
			mapData.SerializeToCodedStream(&mapDataBlockCos);
			mapData.Clear();
			wayIDIndex++;
		}
		//sqlite3_finalize(res);
		/*if (verbose) cout << "\rWriting way " << wayIDs.size() << "/" << wayIDs.size() << " (100%)                                        " << endl;
		wayIDs.clear();
		wayIDs.shrink_to_fit();*/

		//Nodes
		uint64_t nodeIDIndex = 0;
		double latDouble, lonDouble;
		nodeIDIndex--; //This is so it's 0 the first time it's incremented
		uint64_t nodeID = 0;
		//uint64_t nodeCount = 0;
		string queryGetOnlyNodesWithTags = "select q1.node_id, ((q2.min_lat + q2.max_lat)/2), ((q2.min_lon + q2.max_lon)/2), q1.key, q1.value, (case when q1.key in (" + TAG_KEYS_HIGH_PRIORITY_WHITELIST + ") then 0 when key in (" + TAG_KEYS_HUMAN_READABLE_WHITELIST + ") then 2 else 1 end) as tagType from node_tags q1 inner join rtree_node q2 on q2.node_id=q1.node_id where (q2.max_lat >= :bottom and q2.min_lat <= :top) and (q2.max_lon >= :left and q2.min_lon <= :right) order by q1.node_id asc, tagType asc, key asc, value asc;";
		if (mediumZoom) {
			queryGetOnlyNodesWithTags = "select q1.node_id, ((q2.min_lat + q2.max_lat)/2), ((q2.min_lon + q2.max_lon)/2), q1.key, q1.value, (case when q1.key in (" + TAG_KEYS_HIGH_PRIORITY_WHITELIST + ") then 0 when key in (" + TAG_KEYS_HUMAN_READABLE_WHITELIST + ") then 2 else 1 end) as tagType from node_tags q1 inner join rtree_node q2 on q2.node_id=q1.node_id where ((key = 'highway' and value in ('motorway', 'motorway_link', 'motorway_junction', 'primary', 'primary_link', 'secondary', 'secondary_link', 'tertiary', 'tertiary_link', 'trunk', 'trunk_link')) or (key in ('lanes', 'lanes:forward', 'lanes:backward', 'hgv', 'maxspeed', 'oneway', 'name', 'ref', 'destination', 'motorway_link'))) and (q2.max_lat >= :bottom and q2.min_lat <= :top) and (q2.max_lon >= :left and q2.min_lon <= :right) order by q1.node_id asc, tagType asc, key asc, value asc;";
		}
		rc = sqlite3_prepare_v2(dbConnection, queryGetOnlyNodesWithTags.c_str(), -1, &stmt, 0);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":left"), rectangle->left);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":right"), rectangle->right);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":bottom"), rectangle->bottom);
		sqlite3_bind_double(stmt, sqlite3_bind_parameter_index(stmt, ":top"), rectangle->top);
		mapData.Clear();
		coordinatesByteLength = 0;
		coordinatesCount = 0;
		coordinatesByteArrayPtr = coordinatesByteArrayPtrWithinThread;
		typesByteArrayPtr = typesByteArrayPtrWithinThread;
		additionalTypesByteArrayPtr = additionalTypesByteArrayPtrWithinThread;
		stringNamesByteArrayPtr = stringNamesByteArrayPtrWithinThread;
		while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
			if (sqlite3_column_int64(stmt, 0) != nodeID) {
				nodeIDIndex++;
				//if (nodeIDIndex == 0) nodeCount = sqlite3_column_int64(stmt, 6);
				nodeID = sqlite3_column_int64(stmt, 0);
				//if (verbose && (nodeCount < 1000 || (nodeIDIndex % 999 == 0))) cout << "\rWriting node " << (nodeIDIndex + 1) << "/" << nodeCount << " (" << ((nodeIDIndex + 1) * 100.0) / nodeCount << "%)";
				//We're starting a new node so write the current one and clear the protobuf message
				if (nodeIDIndex > 0) {
					mapData.set_coordinates(reinterpret_cast<const char*>(coordinatesByteArrayPtrWithinThread), (coordinatesByteArrayPtr - coordinatesByteArrayPtrWithinThread));
					mapData.set_types(reinterpret_cast<const char*>(typesByteArrayPtrWithinThread), (typesByteArrayPtr - typesByteArrayPtrWithinThread));
					mapData.set_additionaltypes(reinterpret_cast<const char*>(additionalTypesByteArrayPtrWithinThread), (additionalTypesByteArrayPtr - additionalTypesByteArrayPtrWithinThread));
					mapData.set_stringnames(reinterpret_cast<const char*>(stringNamesByteArrayPtrWithinThread), (stringNamesByteArrayPtr - stringNamesByteArrayPtrWithinThread));
					mapData.set_id((((int64_t)nodeID) - ((int64_t)medianUniqueID)) << 7);
					mapDataBlockCos.WriteTag((OsmAnd::OBF::MapDataBlock::kDataObjectsFieldNumber << 3) | 2);
					mapDataBlockCos.WriteVarint32(mapData.ByteSizeLong());
					mapData.SerializeToCodedStream(&mapDataBlockCos);
					mapData.Clear();
					coordinatesByteLength = 0;
					coordinatesCount = 0;
					coordinatesByteArrayPtr = coordinatesByteArrayPtrWithinThread;
					typesByteArrayPtr = typesByteArrayPtrWithinThread;
					additionalTypesByteArrayPtr = additionalTypesByteArrayPtrWithinThread;
					stringNamesByteArrayPtr = stringNamesByteArrayPtrWithinThread;
				}

				latDouble = sqlite3_column_double(stmt, 1);
				lonDouble = sqlite3_column_double(stmt, 2);

				deltaLat = latitudeToInt32(latDouble, 21) - rectangle->topInt32;
				deltaLon = longitudeToInt32(lonDouble, 21) - rectangle->leftInt32;
				//cout << endl << "node deltaLat=" << deltaLat << " (lower 5 bits=" << (deltaLat & 0x1f) << "), deltaLon=" << deltaLon << " (lower 5 bits=" << (deltaLon & 0x1f) << ")" << endl;

				deltaLat >>= 5;
				deltaLon >>= 5;
				//X (longitude)
				coordinatesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(getSInt32FromInt32(deltaLon), coordinatesByteArrayPtr);
				//Y (latitude)
				coordinatesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(getSInt32FromInt32(deltaLat), coordinatesByteArrayPtr);

				//MapData.coordinates
				mapData.set_coordinates(reinterpret_cast<const char*>(coordinatesByteArrayPtrWithinThread), (coordinatesByteArrayPtr - coordinatesByteArrayPtrWithinThread));
			}

			//Write the tags
			string key = (char*)sqlite3_column_text(stmt, 3);
			string value = (char*)sqlite3_column_text(stmt, 4);
			uint32_t tagType = sqlite3_column_int64(stmt, 5); //0 = high-priority machine-readable, 1 = low-priority machine-readable, 2 = human-readable
			//cout << endl << key << "=" << value << ", tagType=" << tagType << endl;
			switch (tagType) {
				case 0: //High-priority machine-readable
					{
						typesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(keyMap[key + "=" + value] + 1, typesByteArrayPtr);
						break;
					}
				case 1: //Low-priority machine-readable
					{
						additionalTypesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(keyMap[key + "=" + value] + 1, additionalTypesByteArrayPtr);
						break;
					}
				case 2: //Human-readable
					{
						//cout << endl << "keyMap[\"" << key << "=\"] + 1 = " << keyMap[key + "="] + 1;
						stringNamesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(keyMap[key + "="] + 1, stringNamesByteArrayPtr);
						stringNamesByteArrayPtr = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(stringTable[value], stringNamesByteArrayPtr);
						break;
					}
			}
		}
		mapData.set_types(reinterpret_cast<const char*>(typesByteArrayPtrWithinThread), (typesByteArrayPtr - typesByteArrayPtrWithinThread));
		mapData.set_additionaltypes(reinterpret_cast<const char*>(additionalTypesByteArrayPtrWithinThread), (additionalTypesByteArrayPtr - additionalTypesByteArrayPtrWithinThread));
		mapData.set_stringnames(reinterpret_cast<const char*>(stringNamesByteArrayPtrWithinThread), (stringNamesByteArrayPtr - stringNamesByteArrayPtrWithinThread));
		mapData.set_id(((((int64_t)nodeID) - ((int64_t)medianUniqueID)) << 7) | (isArea ? 0x7f : 0));
		mapData.set_coordinates(reinterpret_cast<const char*>(coordinatesByteArrayPtrWithinThread), (coordinatesByteArrayPtr - coordinatesByteArrayPtrWithinThread));
		mapDataBlockCos.WriteTag((OsmAnd::OBF::MapDataBlock::kDataObjectsFieldNumber << 3) | 2);
		mapDataBlockCos.WriteVarint32(mapData.ByteSizeLong());
		mapData.SerializeToCodedStream(&mapDataBlockCos);
		mapData.Clear();
		sqlite3_finalize(stmt);
		stmt = nullptr;

		//if (verbose) cout << "\rWriting node " << nodeCount << "/" << nodeCount << " (100%)                                        ";

		//It would be good to alternate storing the StringTable before and after the MapData object because storing similar data together (MapData/StringTable/StringTable/MapData/MapData/etc.) can be compressed better but OsmAnd seems to expect it to be at the end or everything in every other block says "#[index] NOT FOUND"
		mapDataBlockCos.WriteTag((OsmAnd::OBF::MapDataBlock::kStringTableFieldNumber << 3) | 2);
		uint64_t stringTableSize = (shouldSkipBlock ? 0 : getFileSize(string("mapDataBlockStringTable_" + tempFilename)));
		//writeOBFVarint32or64BE(mapDataBlockCos, stringTableSize);
		mapDataBlockCos.WriteVarint32(stringTableSize);
		copyRawFileIntoCodedOutputStream(mapDataBlockCos, "mapDataBlockStringTable_" + tempFilename, stringTableSize);
		if (!shouldKeepTempFiles) remove(string("mapDataBlockStringTable_" + tempFilename).c_str());
	}
	if (shouldShowGUI && !shouldSkipBlock) {
		progressBitmapPtr[(blockIdx * 4)] = 0;
		progressBitmapPtr[(blockIdx * 4) + 1] = 0xc0;
		progressBitmapPtr[(blockIdx * 4) + 2] = 0x00;
		progressBitmapPtr[(blockIdx * 4) + 3] = 255;
	}
}

void VWSimplify(vector<uint64_t> *nodeIDVector, vector<uint64_t> *latVector, vector<uint64_t> *lonVector, uint64_t minAreaX2) {
	if (latVector->size() < 3) return;
	//cout << endl << "Starting VWSimplify() with " << nodeIDVector->size() << " nodes";
	//vector<uint64_t> triangleSizes;
	uint64_t currentMinimum = 0;
	uint64_t currentMinimumIdx = 1;
	uint64_t currentValue = 0;
	bool foundNodeToDelete = false;
	//triangleSizes.reserve(nodeIDVector->size() - 2);
	int64_t x1, x2, x3, y1, y2, y3;
	do {
		foundNodeToDelete = false;
		currentMinimumIdx = 1;
		//cout << endl << "VWSimplify(): about to process " << latVector->size() << " nodes";
		for (int i = 1; i < nodeIDVector->size() - 1; i++) {
			x1 = lonVector->at(i - 1);
			x2 = lonVector->at(i);
			x3 = lonVector->at(i + 1);
			y1 = latVector->at(i - 1);
			y2 = latVector->at(i);
			y3 = latVector->at(i + 1);
			currentValue = abs((x1 * (y2 - y3)) + (x2 * (y3 - y1)) + (x3 * (y1 - y2)));
			if (currentValue < minAreaX2) foundNodeToDelete = true;
			if (i == 1) {
				currentMinimum = currentValue;
			}
			//triangleSizes.emplace_back(currentValue);
			if (currentValue < currentMinimum) {
				currentMinimum = currentValue;
				currentMinimumIdx = i;
			}
			//cout << endl << "Triangle area * 2: " << currentValue;
		}
		if (foundNodeToDelete) {
			//cout << endl << "Should remove node " << currentMinimumIdx << " (" << nodeIDVector->at(currentMinimumIdx) << ") with area * 2 = " << currentMinimum;
			nodeIDVector->erase(nodeIDVector->begin() + currentMinimumIdx);
			//nodeOrderVector->erase(nodeOrderVector->begin() + currentMinimumIdx);
			latVector->erase(latVector->begin() + currentMinimumIdx);
			lonVector->erase(lonVector->begin() + currentMinimumIdx);
			//indexWithinWayVector->erase(indexWithinWayVector->begin() + currentMinimumIdx);
		}
	} while (foundNodeToDelete);
}

void writeMapEncodingRule(string tag, string value, uint32_t minZoom) {
	remove("mapEncodingRule");
	ofstream mapEncodingRuleTemp("mapEncodingRule", ios::binary);
	google::protobuf::io::OstreamOutputStream mapEncodingRuleTempOstream(&mapEncodingRuleTemp);
	google::protobuf::io::CodedOutputStream mapEncodingRuleCos(&mapEncodingRuleTempOstream);

	OsmAnd::OBF::OsmAndMapIndex::MapEncodingRule r;
	r.set_tag(tag);
	if (!value.empty()) r.set_value(value);
	r.set_minzoom(minZoom);

	r.SerializeToCodedStream(&mapEncodingRuleCos);
}

uint64_t copyRawFileIntoCodedOutputStream(google::protobuf::io::CodedOutputStream &cos, string filename, int64_t size) {
	//int64_t fileSize = getFileSize(utf8_to_wstring(filename).c_str());
	if (size < 0) return -1;
	uint32_t chunks = size / FILE_COPY_BUFFER_SIZE;
	uint64_t partialChunkSize = size % FILE_COPY_BUFFER_SIZE;
	//cout << endl << "size=" << size << ", chunks=" << chunks << ", partialChunkSize=" << partialChunkSize;
	uint64_t bytesWritten = 0;
	bool copyPartialChunk = partialChunkSize > 0;
	ifstream input(filename, ios::binary);
	for (int i = 0; i < chunks; i++) {
		input.read((char*)fileCopyBuffer, FILE_COPY_BUFFER_SIZE);
		cos.WriteRaw(fileCopyBuffer, FILE_COPY_BUFFER_SIZE);
		bytesWritten += FILE_COPY_BUFFER_SIZE;
	}
	if (copyPartialChunk) {
		input.read((char*)fileCopyBuffer, partialChunkSize);
		cos.WriteRaw(fileCopyBuffer, partialChunkSize);
		bytesWritten += partialChunkSize;
	}
	return bytesWritten;
}

void copyRawInputStreamIntoCodedOutputStream(google::protobuf::io::CodedOutputStream &cos, istream *inputFile, int64_t size) {
	//int64_t fileSize = getFileSize(utf8_to_wstring(filename).c_str());
	if (size < 0) return;
	uint32_t chunks = size / FILE_COPY_BUFFER_SIZE;
	uint64_t partialChunkSize = size % FILE_COPY_BUFFER_SIZE;
	//cout << endl << "size=" << size << ", chunks=" << chunks << ", partialChunkSize=" << partialChunkSize;
	uint64_t bytesWritten = 0;
	bool copyPartialChunk = partialChunkSize > 0;
	for (int i = 0; i < chunks; i++) {
		inputFile->read((char*)fileCopyBuffer, FILE_COPY_BUFFER_SIZE);
		cos.WriteRaw(fileCopyBuffer, FILE_COPY_BUFFER_SIZE);
		bytesWritten += FILE_COPY_BUFFER_SIZE;
	}
	if (copyPartialChunk) {
		inputFile->read((char*)fileCopyBuffer, partialChunkSize);
		cos.WriteRaw(fileCopyBuffer, partialChunkSize);
		bytesWritten += partialChunkSize;
	}
}

string humanReadableTimeFromSeconds(unsigned int seconds) {
	unsigned int days = seconds / 86400;
	seconds %= 86400;
	unsigned int hours = seconds / 3600;
	seconds %= 3600;
	unsigned int minutes = seconds / 60;
	seconds %= 60;
	string retVal = to_string(seconds) + "s";
	if (minutes > 0) {
		retVal = to_string(minutes) + "m" + (seconds < 10 ? "0" : "") + retVal;
	}
	if (hours > 0) {
		retVal = to_string(hours) + "h" + (minutes < 10 ? "0" : "") + retVal;
	}
	if (days > 0) {
		retVal = to_string(days) + "d" + (hours < 10 ? "0" : "") + retVal;
	}
	return retVal;
}

static inline int64_t getFileSize(string name) {
	return filesystem::file_size(filesystem::path(name));
}

//Copied from user 毕晓峰 on StackOverflow
//https://stackoverflow.com/a/35644947
// convert UTF-8 string to wstring
std::wstring utf8_to_wstring(const std::string& str)
{
	std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
	return myconv.from_bytes(str);
}
// convert wstring to UTF-8 string
std::string wstring_to_utf8(const std::wstring& str)
{
	std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
	return myconv.to_bytes(str);
}

void writeOBFVarint32or64BE(google::protobuf::io::CodedOutputStream &i, uint64_t n) {
	//cout << endl << "n=" << n;
	//The OBF format uses a type of big endian varint for submessage lengths where it's at least 32 bits but the MSB of the first 32 bits says whether there is another 32 bits
	if (n > 0x7fffffff) {
		n |= 0x8000000000000000;
		uint64_t nBigEndian = swap_endian(n);
		i.WriteRaw(&nBigEndian, 8);
	}
	else {
		n &= 0x7fffffffffffffff;
		n <<= 32;
		uint64_t nBigEndian = swap_endian(n);
		i.WriteRaw(&nBigEndian, 4);
	}
}

static inline uint64_t GetSystemTimeAsUnixTime() {
	return (uint64_t)(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
}

double int32ToLatitude(uint64_t in, uint32_t zoom) {
	return (atan((sinh(((-2*(in/1024.0))/(1<<zoom) + 1) * PI))) * 180)/PI;
}

double int32ToLongitude(uint64_t in, uint32_t zoom) {
	return (((in/1024.0)/(1<<zoom))*360.0) - 180.0;
}

//Round the latitude and longitude int32 values to a multiple of 32 since the lower 5 bits are usually dropped anyway and preserving them introduces rounding errors
static inline int32_t latitudeToInt32(double latitude, uint32_t zoom, bool fullAccuracy) {
	int32_t retVal = ((int32_t)(((((asinh(tan((latitude * PI) / 180) / (latitude < 0 ? -1.0 : 1.0)) / PI) - 1) * (1 << zoom)) / -2) * 1024));
	//unsigned int remainder = retVal & 0x1f;
	/*if (remainder < 8) {
		retVal -= 32;
	} else if (remainder > 24) {
		retVal += 32;
	}*/
	/*if (remainder >= 16) {
		retVal += 32;
	}*/
	if (!fullAccuracy) retVal &= 0xffffffe0;
	return retVal;
}

static inline int32_t longitudeToInt32(double longitude, uint32_t zoom, bool fullAccuracy) {
	int32_t retVal = ((int32_t)(((longitude + 180.0) / 360.0) * (1 << zoom) * 1024.0));
	//unsigned int remainder = retVal & 0x1f;
	/*if (remainder < 8) {
		retVal -= 32;
	} else if (remainder > 24) {
		retVal += 32;
	}*/
	/*if (remainder >= 16) {
		retVal += 32;
	}*/
	if (!fullAccuracy) retVal &= 0xffffffe0;
	return retVal;
}

uint32_t getVarintRequiredBytes(uint64_t i) {
	if (i <= 127) {
		return 1;
	} else if (i <= 16383) {
		return 2;
	} else if (i <= 2097151) {
		return 3;
	} else if (i <= 268435455) {
		return 4;
	} else if (i <= 34359738367) {
		return 5;
	} else if (i <= 0xFFFFFFFFFFff) {
		return 6;
	} else if (i <= 0x7FFFFFFFFFFFff) {
		return 7;
	} else if (i <= 0x3FFFFFFFFFFFFFff) {
		return 8;
	}
	return 0;
}

//Copied from StackOverflow user Sudhanshu
//https://stackoverflow.com/q/2039730
static inline int min3(int64_t a, int64_t b, int64_t c) {
	int64_t m = a;
	if (m > b) m = b;
	if (m > c) m = c;
	return m;
}