apply clang-format to tool sources

54 files changed, 5867 insertions, 7112 deletions

diff --git a/tools/src/aif2pcm/extended.c b/tools/src/aif2pcm/extended.c
index 94449164..33911c01 100755..100644
--- a/tools/src/aif2pcm/extended.c
+++ b/tools/src/aif2pcm/extended.c
@@ -35,12 +35,12 @@
  */
 #ifndef HUGE_VAL
 #ifdef HUGE
-#define INFINITE_VALUE	HUGE
-#define NAN_VALUE	HUGE
+#define INFINITE_VALUE HUGE
+#define NAN_VALUE HUGE
 #endif
 #else
-#define INFINITE_VALUE	HUGE_VAL
-#define NAN_VALUE	HUGE_VAL
+#define INFINITE_VALUE HUGE_VAL
+#define NAN_VALUE HUGE_VAL
 #endif
 
 /*
@@ -62,111 +62,103 @@
 /*
  * Write IEEE Extended Precision Numbers
  */
-void
-ieee754_write_extended(double in, uint8_t* out)
-{
-	int sgn, exp, shift;
-	double fraction, t;
-	unsigned int lexp, hexp;
-	unsigned long low, high;
-
-	if (in == 0.0) {
-		memset(out, 0, 10);
-		return;
-	}
-	if (in < 0.0) {
-		in = fabs(in);
-		sgn = 1;
-	} else
-		sgn = 0;
-
-	fraction = frexp(in, &exp);
-
-	if (exp == 0 || exp > 16384) {
-		if (exp > 16384) /* infinite value */
-			low = high = 0;
-		else {
-			low = 0x80000000;
-			high = 0;
-		}
-		exp = 32767;
-		goto done;
-	}
-	fraction = ldexp(fraction, 32);
-	t = floor(fraction);
-	low = (unsigned long) t;
-	fraction -= t;
-	t = floor(ldexp(fraction, 32));
-	high = (unsigned long) t;
-
-	/* Convert exponents < -16382 to -16382 (then they will be
-	 * stored as -16383) */
-	if (exp < -16382) {
-		shift = 0 - exp - 16382;
-		high >>= shift;
-		high |= (low << (32 - shift));
-		low >>= shift;
-		exp = -16382;
-	}
-	exp += 16383 - 1;	/* bias */
+void ieee754_write_extended(double in, uint8_t* out) {
+    int sgn, exp, shift;
+    double fraction, t;
+    unsigned int lexp, hexp;
+    unsigned long low, high;
+
+    if (in == 0.0) {
+        memset(out, 0, 10);
+        return;
+    }
+    if (in < 0.0) {
+        in = fabs(in);
+        sgn = 1;
+    } else
+        sgn = 0;
+
+    fraction = frexp(in, &exp);
+
+    if (exp == 0 || exp > 16384) {
+        if (exp > 16384) /* infinite value */
+            low = high = 0;
+        else {
+            low = 0x80000000;
+            high = 0;
+        }
+        exp = 32767;
+        goto done;
+    }
+    fraction = ldexp(fraction, 32);
+    t = floor(fraction);
+    low = (unsigned long)t;
+    fraction -= t;
+    t = floor(ldexp(fraction, 32));
+    high = (unsigned long)t;
+
+    /* Convert exponents < -16382 to -16382 (then they will be
+     * stored as -16383) */
+    if (exp < -16382) {
+        shift = 0 - exp - 16382;
+        high >>= shift;
+        high |= (low << (32 - shift));
+        low >>= shift;
+        exp = -16382;
+    }
+    exp += 16383 - 1; /* bias */
 
 done:
-	lexp = ((unsigned int) exp) >> 8;
-	hexp = ((unsigned int) exp) & 0xFF;
-
-	/* big endian */
-	out[0] = ((uint8_t) sgn) << 7;
-	out[0] |= (uint8_t) lexp;
-	out[1] = (uint8_t) hexp;
-	out[2] = (uint8_t) (low >> 24);
-	out[3] = (uint8_t) ((low >> 16) & 0xFF);
-	out[4] = (uint8_t) ((low >> 8) & 0xFF);
-	out[5] = (uint8_t) (low & 0xFF);
-	out[6] = (uint8_t) (high >> 24);
-	out[7] = (uint8_t) ((high >> 16) & 0xFF);
-	out[8] = (uint8_t) ((high >> 8) & 0xFF);
-	out[9] = (uint8_t) (high & 0xFF);
-
-	return;
+    lexp = ((unsigned int)exp) >> 8;
+    hexp = ((unsigned int)exp) & 0xFF;
+
+    /* big endian */
+    out[0] = ((uint8_t)sgn) << 7;
+    out[0] |= (uint8_t)lexp;
+    out[1] = (uint8_t)hexp;
+    out[2] = (uint8_t)(low >> 24);
+    out[3] = (uint8_t)((low >> 16) & 0xFF);
+    out[4] = (uint8_t)((low >> 8) & 0xFF);
+    out[5] = (uint8_t)(low & 0xFF);
+    out[6] = (uint8_t)(high >> 24);
+    out[7] = (uint8_t)((high >> 16) & 0xFF);
+    out[8] = (uint8_t)((high >> 8) & 0xFF);
+    out[9] = (uint8_t)(high & 0xFF);
+
+    return;
 }
 
-
 /*
  * Read IEEE Extended Precision Numbers
  */
-double
-ieee754_read_extended(uint8_t* in)
-{
-	int sgn, exp;
-	unsigned long low, high;
-	double out;
-
-	/* Extract the components from the big endian buffer */
-	sgn = (int) (in[0] >> 7);
-	exp = ((int) (in[0] & 0x7F) << 8) | ((int) in[1]);
-	low = (((unsigned long) in[2]) << 24)
-		| (((unsigned long) in[3]) << 16)
-		| (((unsigned long) in[4]) << 8) | (unsigned long) in[5];
-	high = (((unsigned long) in[6]) << 24)
-		| (((unsigned long) in[7]) << 16)
-		| (((unsigned long) in[8]) << 8) | (unsigned long) in[9];
-
-	if (exp == 0 && low == 0 && high == 0)
-		return (sgn ? -0.0 : 0.0);
-
-	switch (exp) {
-	case 32767:
-		if (low == 0 && high == 0)
-			return (sgn ? -INFINITE_VALUE : INFINITE_VALUE);
-		else
-			return (sgn ? -NAN_VALUE : NAN_VALUE);
-	default:
-		exp -= 16383;	/* unbias exponent */
-
-	}
-
-	out = ldexp((double) low, -31 + exp);
-	out += ldexp((double) high, -63 + exp);
-
-	return (sgn ? -out : out);
+double ieee754_read_extended(uint8_t* in) {
+    int sgn, exp;
+    unsigned long low, high;
+    double out;
+
+    /* Extract the components from the big endian buffer */
+    sgn = (int)(in[0] >> 7);
+    exp = ((int)(in[0] & 0x7F) << 8) | ((int)in[1]);
+    low = (((unsigned long)in[2]) << 24) | (((unsigned long)in[3]) << 16) | (((unsigned long)in[4]) << 8) |
+          (unsigned long)in[5];
+    high = (((unsigned long)in[6]) << 24) | (((unsigned long)in[7]) << 16) | (((unsigned long)in[8]) << 8) |
+           (unsigned long)in[9];
+
+    if (exp == 0 && low == 0 && high == 0)
+        return (sgn ? -0.0 : 0.0);
+
+    switch (exp) {
+        case 32767:
+            if (low == 0 && high == 0)
+                return (sgn ? -INFINITE_VALUE : INFINITE_VALUE);
+            else
+                return (sgn ? -NAN_VALUE : NAN_VALUE);
+        default:
+            exp -= 16383; /* unbias exponent */
+    }
+
+    out = ldexp((double)low, -31 + exp);
+    out += ldexp((double)high, -63 + exp);
+
+    return (sgn ? -out : out);
 }
diff --git a/tools/src/aif2pcm/main.c b/tools/src/aif2pcm/main.c
index cd5ac4a5..50616519 100755..100644
--- a/tools/src/aif2pcm/main.c
+++ b/tools/src/aif2pcm/main.c
@@ -26,863 +26,774 @@
 #include <limits.h>
 
 /* extended.c */
-void ieee754_write_extended (double, uint8_t*);
-double ieee754_read_extended (uint8_t*);
+void ieee754_write_extended(double, uint8_t*);
+double ieee754_read_extended(uint8_t*);
 
 #ifdef _MSC_VER
 
-#define FATAL_ERROR(format, ...)           \
-do                                         \
-{                                          \
-	fprintf(stderr, format, __VA_ARGS__);  \
-	exit(1);                               \
-} while (0)
+#define FATAL_ERROR(format, ...)              \
+    do {                                      \
+        fprintf(stderr, format, __VA_ARGS__); \
+        exit(1);                              \
+    } while (0)
 
 #else
 
-#define FATAL_ERROR(format, ...)            \
-do                                          \
-{                                           \
-	fprintf(stderr, format, ##__VA_ARGS__); \
-	exit(1);                                \
-} while (0)
+#define FATAL_ERROR(format, ...)                \
+    do {                                        \
+        fprintf(stderr, format, ##__VA_ARGS__); \
+        exit(1);                                \
+    } while (0)
 
 #endif // _MSC_VER
 
 typedef struct {
-	unsigned long num_samples;
-	uint8_t *samples;
-	uint8_t midi_note;
-	bool has_loop;
-	unsigned long loop_offset;
-	double sample_rate;
-	unsigned long real_num_samples;
+    unsigned long num_samples;
+    uint8_t* samples;
+    uint8_t midi_note;
+    bool has_loop;
+    unsigned long loop_offset;
+    double sample_rate;
+    unsigned long real_num_samples;
 } AifData;
 
 struct Bytes {
-	unsigned long length;
-	uint8_t *data;
+    unsigned long length;
+    uint8_t* data;
 };
 
 struct Marker {
-	unsigned short id;
-	unsigned long position;
-	// don't care about the name
+    unsigned short id;
+    unsigned long position;
+    // don't care about the name
 };
 
-struct Bytes *read_bytearray(const char *filename)
-{
-	struct Bytes *bytes = malloc(sizeof(struct Bytes));
-	FILE *f = fopen(filename, "rb");
-	if (!f)
-	{
-		FATAL_ERROR("Failed to open '%s' for reading!\n", filename);
-	}
-	fseek(f, 0, SEEK_END);
-	bytes->length = ftell(f);
-	fseek(f, 0, SEEK_SET);
-	bytes->data = malloc(bytes->length);
-	unsigned long read = fread(bytes->data, bytes->length, 1, f);
-	fclose(f);
-	if (read <= 0)
-	{
-		FATAL_ERROR("Failed to read data from '%s'!\n", filename);
-	}
-	return bytes;
+struct Bytes* read_bytearray(const char* filename) {
+    struct Bytes* bytes = malloc(sizeof(struct Bytes));
+    FILE* f = fopen(filename, "rb");
+    if (!f) {
+        FATAL_ERROR("Failed to open '%s' for reading!\n", filename);
+    }
+    fseek(f, 0, SEEK_END);
+    bytes->length = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    bytes->data = malloc(bytes->length);
+    unsigned long read = fread(bytes->data, bytes->length, 1, f);
+    fclose(f);
+    if (read <= 0) {
+        FATAL_ERROR("Failed to read data from '%s'!\n", filename);
+    }
+    return bytes;
 }
 
-void write_bytearray(const char *filename, struct Bytes *bytes)
-{
-	FILE *f = fopen(filename, "wb");
-	if (!f)
-	{
-		FATAL_ERROR("Failed to open '%s' for writing!\n", filename);
-	}
-	fwrite(bytes->data, bytes->length, 1, f);
-	fclose(f);
+void write_bytearray(const char* filename, struct Bytes* bytes) {
+    FILE* f = fopen(filename, "wb");
+    if (!f) {
+        FATAL_ERROR("Failed to open '%s' for writing!\n", filename);
+    }
+    fwrite(bytes->data, bytes->length, 1, f);
+    fclose(f);
 }
 
-void free_bytearray(struct Bytes *bytes)
-{
-	free(bytes->data);
-	free(bytes);
+void free_bytearray(struct Bytes* bytes) {
+    free(bytes->data);
+    free(bytes);
 }
 
-char *get_file_extension(char *filename)
-{
-	char *index = strrchr(filename, '.');
-	if (!index || index == filename)
-	{
-		return NULL;
-	}
-	return index + 1;
+char* get_file_extension(char* filename) {
+    char* index = strrchr(filename, '.');
+    if (!index || index == filename) {
+        return NULL;
+    }
+    return index + 1;
 }
 
-char *new_file_extension(char *filename, char *ext)
-{
-	char *index = strrchr(filename, '.');
-	if (!index || index == filename)
-	{
-		index = filename + strlen(filename);
-	}
-	int length = index - filename;
-	char *new_filename = malloc(length + 1 + strlen(ext) + 1);
-	if (new_filename)
-	{
-		strcpy(new_filename, filename);
-		new_filename[length] = '.';
-		strcpy(new_filename + length + 1, ext);
-	}
-	return new_filename;
+char* new_file_extension(char* filename, char* ext) {
+    char* index = strrchr(filename, '.');
+    if (!index || index == filename) {
+        index = filename + strlen(filename);
+    }
+    int length = index - filename;
+    char* new_filename = malloc(length + 1 + strlen(ext) + 1);
+    if (new_filename) {
+        strcpy(new_filename, filename);
+        new_filename[length] = '.';
+        strcpy(new_filename + length + 1, ext);
+    }
+    return new_filename;
 }
 
-void read_aif(struct Bytes *aif, AifData *aif_data)
-{
-	aif_data->has_loop = false;
-	aif_data->num_samples = 0;
-
-	unsigned long pos = 0;
-	char chunk_name[5]; chunk_name[4] = '\0';
-	char chunk_type[5]; chunk_type[4] = '\0';
-
-	// Check for FORM Chunk
-	memcpy(chunk_name, &aif->data[pos], 4);
-	pos += 4;
-	if (strcmp(chunk_name, "FORM") != 0)
-	{
-		FATAL_ERROR("Input .aif file has invalid header Chunk '%s'!\n", chunk_name);
-	}
-
-	// Read size of whole file.
-	unsigned long whole_chunk_size = aif->data[pos++] << 24;
-	whole_chunk_size |= (aif->data[pos++] << 16);
-	whole_chunk_size |= (aif->data[pos++] <<  8);
-	whole_chunk_size |= (uint8_t)aif->data[pos++];
-
-	unsigned long expected_whole_chunk_size = aif->length - 8;
-	if (whole_chunk_size != expected_whole_chunk_size)
-	{
-		FATAL_ERROR("FORM Chunk ckSize '%lu' doesn't match actual size '%lu'!\n", whole_chunk_size, expected_whole_chunk_size);
-	}
-
-	// Check for AIFF Form Type
-	memcpy(chunk_type, &aif->data[pos], 4);
-	pos += 4;
-	if (strcmp(chunk_type, "AIFF") != 0)
-	{
-		FATAL_ERROR("FORM Type is '%s', but it must be AIFF!", chunk_type);
-	}
-
-	struct Marker *markers = NULL;
-	unsigned short num_markers = 0, loop_start = 0, loop_end = 0;
-	unsigned long num_sample_frames = 0;
-
-	// Read all the Chunks to populate the AifData struct.
-	while ((pos + 8) < aif->length)
-	{
-		// Read Chunk id
-		memcpy(chunk_name, &aif->data[pos], 4);
-		pos += 4;
-
-		unsigned long chunk_size = (aif->data[pos++] << 24);
-		chunk_size |= (aif->data[pos++] << 16);
-		chunk_size |= (aif->data[pos++] <<  8);
-		chunk_size |=  aif->data[pos++];
-
-		if ((pos + chunk_size) > aif->length)
-		{
-			FATAL_ERROR("%s chunk at 0x%lx reached end of file before finishing\n", chunk_name, pos);
-		}
-
-		if (strcmp(chunk_name, "COMM") == 0)
-		{
-			short num_channels = (aif->data[pos++] << 8);
-			num_channels |= (uint8_t)aif->data[pos++];
-			if (num_channels != 1)
-			{
-				FATAL_ERROR("numChannels (%d) in the COMM Chunk must be 1!\n", num_channels);
-			}
-
-			num_sample_frames =  (aif->data[pos++] << 24);
-			num_sample_frames |= (aif->data[pos++] << 16);
-			num_sample_frames |= (aif->data[pos++] <<  8);
-			num_sample_frames |=  (uint8_t)aif->data[pos++];
-
-			short sample_size = (aif->data[pos++] << 8);
-			sample_size |= (uint8_t)aif->data[pos++];
-			if (sample_size != 8)
-			{
-				FATAL_ERROR("sampleSize (%d) in the COMM Chunk must be 8!\n", sample_size);
-			}
-
-			double sample_rate = ieee754_read_extended((uint8_t*)(aif->data + pos));
-			pos += 10;
-
-			aif_data->sample_rate = sample_rate;
-
-			if (aif_data->num_samples == 0)
-			{
-				aif_data->num_samples = num_sample_frames;
-			}
-		}
-		else if (strcmp(chunk_name, "MARK") == 0)
-		{
-			num_markers = (aif->data[pos++] << 8);
-			num_markers |= (uint8_t)aif->data[pos++];
-
-			if (markers)
-			{
-				FATAL_ERROR("More than one MARK Chunk in file!\n");
-			}
-			
-			markers = calloc(num_markers, sizeof(struct Marker));
-
-			// Read each marker.
-			for (int i = 0; i < num_markers; i++)
-			{
-				unsigned short marker_id = (aif->data[pos++] << 8);
-				marker_id |= (uint8_t)aif->data[pos++];
-
-				unsigned long marker_position = (aif->data[pos++] << 24);
-				marker_position |= (aif->data[pos++] << 16);
-				marker_position |= (aif->data[pos++] << 8);
-				marker_position |=  (uint8_t)aif->data[pos++];
-
-				// Marker name is a Pascal-style string.
-				uint8_t marker_name_size = aif->data[pos++];
-				// We don't actually need the marker name for anything anymore.
-				/*char *marker_name = (char *)malloc((marker_name_size + 1) * sizeof(char));
-				memcpy(marker_name, &aif->data[pos], marker_name_size);
-				marker_name[marker_name_size] = '\0';*/
-				pos += marker_name_size + !(marker_name_size & 1);
-
-				markers[i].id = marker_id;
-				markers[i].position = marker_position;
-			}
-		}
-		else if (strcmp(chunk_name, "INST") == 0)
-		{
-			uint8_t midi_note = (uint8_t)aif->data[pos++];
-
-			aif_data->midi_note = midi_note;
-
-			// Skip over data we don't need.
-			pos += 7;
-
-			unsigned short loop_type = (aif->data[pos++] << 8);
-			loop_type |= (uint8_t)aif->data[pos++];
-
-			if (loop_type)
-			{
-				loop_start = (aif->data[pos++] << 8);
-				loop_start |= (uint8_t)aif->data[pos++];
-
-				loop_end = (aif->data[pos++] << 8);
-				loop_end |= (uint8_t)aif->data[pos++];
-			}
-			else
-			{
-				// Skip NoLooping sustain loop.
-				pos += 4;
-			}
-			
-			// Skip release loop, we don't need it.
-			pos += 6;
-		}
-		else if (strcmp(chunk_name, "SSND") == 0)
-		{
-			// Skip offset and blockSize
-			pos += 8;
-
-			unsigned long num_samples = chunk_size - 8;
-			uint8_t *sample_data = (uint8_t *)malloc(num_samples * sizeof(uint8_t));
-			memcpy(sample_data, &aif->data[pos], num_samples);
-
-			aif_data->samples = sample_data;
-			aif_data->real_num_samples = num_samples;
-			pos += chunk_size - 8;
-		}
-		else
-		{
-			// Skip over unsupported chunks.
-			pos += chunk_size;
-		}
-	}
-	
-	if (markers)
-	{
-		// Resolve loop points.
-		struct Marker *cur_marker = markers;
-	
-		// Grab loop start point.
-		for (int i = 0; i < num_markers; i++, cur_marker++)
-		{
-			if (cur_marker->id == loop_start)
-			{
-				aif_data->loop_offset = cur_marker->position;
-				aif_data->has_loop = true;
-				break;
-			}
-		}
-
-		cur_marker = markers;
-
-		// Grab loop end point.
-		for (int i = 0; i < num_markers; i++, cur_marker++)
-		{
-			if (cur_marker->id == loop_end)
-			{
-				if (cur_marker->position < aif_data->loop_offset) {
-					aif_data->loop_offset = cur_marker->position;
-					aif_data->has_loop = true;
-				}
-				aif_data->num_samples = cur_marker->position;
-				break;
-			}
-		}
-
-		free(markers);
-	}
+void read_aif(struct Bytes* aif, AifData* aif_data) {
+    aif_data->has_loop = false;
+    aif_data->num_samples = 0;
+
+    unsigned long pos = 0;
+    char chunk_name[5];
+    chunk_name[4] = '\0';
+    char chunk_type[5];
+    chunk_type[4] = '\0';
+
+    // Check for FORM Chunk
+    memcpy(chunk_name, &aif->data[pos], 4);
+    pos += 4;
+    if (strcmp(chunk_name, "FORM") != 0) {
+        FATAL_ERROR("Input .aif file has invalid header Chunk '%s'!\n", chunk_name);
+    }
+
+    // Read size of whole file.
+    unsigned long whole_chunk_size = aif->data[pos++] << 24;
+    whole_chunk_size |= (aif->data[pos++] << 16);
+    whole_chunk_size |= (aif->data[pos++] << 8);
+    whole_chunk_size |= (uint8_t)aif->data[pos++];
+
+    unsigned long expected_whole_chunk_size = aif->length - 8;
+    if (whole_chunk_size != expected_whole_chunk_size) {
+        FATAL_ERROR("FORM Chunk ckSize '%lu' doesn't match actual size '%lu'!\n", whole_chunk_size,
+                    expected_whole_chunk_size);
+    }
+
+    // Check for AIFF Form Type
+    memcpy(chunk_type, &aif->data[pos], 4);
+    pos += 4;
+    if (strcmp(chunk_type, "AIFF") != 0) {
+        FATAL_ERROR("FORM Type is '%s', but it must be AIFF!", chunk_type);
+    }
+
+    struct Marker* markers = NULL;
+    unsigned short num_markers = 0, loop_start = 0, loop_end = 0;
+    unsigned long num_sample_frames = 0;
+
+    // Read all the Chunks to populate the AifData struct.
+    while ((pos + 8) < aif->length) {
+        // Read Chunk id
+        memcpy(chunk_name, &aif->data[pos], 4);
+        pos += 4;
+
+        unsigned long chunk_size = (aif->data[pos++] << 24);
+        chunk_size |= (aif->data[pos++] << 16);
+        chunk_size |= (aif->data[pos++] << 8);
+        chunk_size |= aif->data[pos++];
+
+        if ((pos + chunk_size) > aif->length) {
+            FATAL_ERROR("%s chunk at 0x%lx reached end of file before finishing\n", chunk_name, pos);
+        }
+
+        if (strcmp(chunk_name, "COMM") == 0) {
+            short num_channels = (aif->data[pos++] << 8);
+            num_channels |= (uint8_t)aif->data[pos++];
+            if (num_channels != 1) {
+                FATAL_ERROR("numChannels (%d) in the COMM Chunk must be 1!\n", num_channels);
+            }
+
+            num_sample_frames = (aif->data[pos++] << 24);
+            num_sample_frames |= (aif->data[pos++] << 16);
+            num_sample_frames |= (aif->data[pos++] << 8);
+            num_sample_frames |= (uint8_t)aif->data[pos++];
+
+            short sample_size = (aif->data[pos++] << 8);
+            sample_size |= (uint8_t)aif->data[pos++];
+            if (sample_size != 8) {
+                FATAL_ERROR("sampleSize (%d) in the COMM Chunk must be 8!\n", sample_size);
+            }
+
+            double sample_rate = ieee754_read_extended((uint8_t*)(aif->data + pos));
+            pos += 10;
+
+            aif_data->sample_rate = sample_rate;
+
+            if (aif_data->num_samples == 0) {
+                aif_data->num_samples = num_sample_frames;
+            }
+        } else if (strcmp(chunk_name, "MARK") == 0) {
+            num_markers = (aif->data[pos++] << 8);
+            num_markers |= (uint8_t)aif->data[pos++];
+
+            if (markers) {
+                FATAL_ERROR("More than one MARK Chunk in file!\n");
+            }
+
+            markers = calloc(num_markers, sizeof(struct Marker));
+
+            // Read each marker.
+            for (int i = 0; i < num_markers; i++) {
+                unsigned short marker_id = (aif->data[pos++] << 8);
+                marker_id |= (uint8_t)aif->data[pos++];
+
+                unsigned long marker_position = (aif->data[pos++] << 24);
+                marker_position |= (aif->data[pos++] << 16);
+                marker_position |= (aif->data[pos++] << 8);
+                marker_position |= (uint8_t)aif->data[pos++];
+
+                // Marker name is a Pascal-style string.
+                uint8_t marker_name_size = aif->data[pos++];
+                // We don't actually need the marker name for anything anymore.
+                /*char *marker_name = (char *)malloc((marker_name_size + 1) * sizeof(char));
+                memcpy(marker_name, &aif->data[pos], marker_name_size);
+                marker_name[marker_name_size] = '\0';*/
+                pos += marker_name_size + !(marker_name_size & 1);
+
+                markers[i].id = marker_id;
+                markers[i].position = marker_position;
+            }
+        } else if (strcmp(chunk_name, "INST") == 0) {
+            uint8_t midi_note = (uint8_t)aif->data[pos++];
+
+            aif_data->midi_note = midi_note;
+
+            // Skip over data we don't need.
+            pos += 7;
+
+            unsigned short loop_type = (aif->data[pos++] << 8);
+            loop_type |= (uint8_t)aif->data[pos++];
+
+            if (loop_type) {
+                loop_start = (aif->data[pos++] << 8);
+                loop_start |= (uint8_t)aif->data[pos++];
+
+                loop_end = (aif->data[pos++] << 8);
+                loop_end |= (uint8_t)aif->data[pos++];
+            } else {
+                // Skip NoLooping sustain loop.
+                pos += 4;
+            }
+
+            // Skip release loop, we don't need it.
+            pos += 6;
+        } else if (strcmp(chunk_name, "SSND") == 0) {
+            // Skip offset and blockSize
+            pos += 8;
+
+            unsigned long num_samples = chunk_size - 8;
+            uint8_t* sample_data = (uint8_t*)malloc(num_samples * sizeof(uint8_t));
+            memcpy(sample_data, &aif->data[pos], num_samples);
+
+            aif_data->samples = sample_data;
+            aif_data->real_num_samples = num_samples;
+            pos += chunk_size - 8;
+        } else {
+            // Skip over unsupported chunks.
+            pos += chunk_size;
+        }
+    }
+
+    if (markers) {
+        // Resolve loop points.
+        struct Marker* cur_marker = markers;
+
+        // Grab loop start point.
+        for (int i = 0; i < num_markers; i++, cur_marker++) {
+            if (cur_marker->id == loop_start) {
+                aif_data->loop_offset = cur_marker->position;
+                aif_data->has_loop = true;
+                break;
+            }
+        }
+
+        cur_marker = markers;
+
+        // Grab loop end point.
+        for (int i = 0; i < num_markers; i++, cur_marker++) {
+            if (cur_marker->id == loop_end) {
+                if (cur_marker->position < aif_data->loop_offset) {
+                    aif_data->loop_offset = cur_marker->position;
+                    aif_data->has_loop = true;
+                }
+                aif_data->num_samples = cur_marker->position;
+                break;
+            }
+        }
+
+        free(markers);
+    }
 }
 
 // This is a table of deltas between sample values in compressed PCM data.
 const int gDeltaEncodingTable[] = {
-	0, 1, 4, 9, 16, 25, 36, 49,
-	-64, -49, -36, -25, -16, -9, -4, -1,
+    0, 1, 4, 9, 16, 25, 36, 49, -64, -49, -36, -25, -16, -9, -4, -1,
 };
 
-struct Bytes *delta_decompress(struct Bytes *delta, unsigned int expected_length)
-{
-	struct Bytes *pcm = malloc(sizeof(struct Bytes));
-	pcm->length = expected_length;
-	pcm->data = malloc(pcm->length + 0x40);
-
-	uint8_t hi, lo;
-	unsigned int i = 0;
-	unsigned int j = 0;
-	int k;
-	int8_t base;
-	while (i < delta->length)
-	{
-		base = (int8_t)delta->data[i++];
-		pcm->data[j++] = (uint8_t)base;
-		if (i >= delta->length)
-		{
-			break;
-		}
-		if (j >= pcm->length)
-		{
-			break;
-		}
-		lo = delta->data[i] & 0xf;
-		base += gDeltaEncodingTable[lo];
-		pcm->data[j++] = base;
-		i++;
-		if (i >= delta->length)
-		{
-			break;
-		}
-		if (j >= pcm->length)
-		{
-			break;
-		}
-		for (k = 0; k < 31; k++)
-		{
-			hi = (delta->data[i] >> 4) & 0xf;
-			base += gDeltaEncodingTable[hi];
-			pcm->data[j++] = base;
-			if (j >= pcm->length)
-			{
-				break;
-			}
-			lo = delta->data[i] & 0xf;
-			base += gDeltaEncodingTable[lo];
-			pcm->data[j++] = base;
-			i++;
-			if (i >= delta->length)
-			{
-				break;
-			}
-			if (j >= pcm->length)
-			{
-				break;
-			}
-		}
-		if (j >= pcm->length)
-		{
-			break;
-		}
-	}
-
-	pcm->length = j;
-	return pcm;
+struct Bytes* delta_decompress(struct Bytes* delta, unsigned int expected_length) {
+    struct Bytes* pcm = malloc(sizeof(struct Bytes));
+    pcm->length = expected_length;
+    pcm->data = malloc(pcm->length + 0x40);
+
+    uint8_t hi, lo;
+    unsigned int i = 0;
+    unsigned int j = 0;
+    int k;
+    int8_t base;
+    while (i < delta->length) {
+        base = (int8_t)delta->data[i++];
+        pcm->data[j++] = (uint8_t)base;
+        if (i >= delta->length) {
+            break;
+        }
+        if (j >= pcm->length) {
+            break;
+        }
+        lo = delta->data[i] & 0xf;
+        base += gDeltaEncodingTable[lo];
+        pcm->data[j++] = base;
+        i++;
+        if (i >= delta->length) {
+            break;
+        }
+        if (j >= pcm->length) {
+            break;
+        }
+        for (k = 0; k < 31; k++) {
+            hi = (delta->data[i] >> 4) & 0xf;
+            base += gDeltaEncodingTable[hi];
+            pcm->data[j++] = base;
+            if (j >= pcm->length) {
+                break;
+            }
+            lo = delta->data[i] & 0xf;
+            base += gDeltaEncodingTable[lo];
+            pcm->data[j++] = base;
+            i++;
+            if (i >= delta->length) {
+                break;
+            }
+            if (j >= pcm->length) {
+                break;
+            }
+        }
+        if (j >= pcm->length) {
+            break;
+        }
+    }
+
+    pcm->length = j;
+    return pcm;
 }
 
-int get_delta_index(uint8_t sample, uint8_t prev_sample)
-{
-	int best_error = INT_MAX;
-	int best_index = -1;
+int get_delta_index(uint8_t sample, uint8_t prev_sample) {
+    int best_error = INT_MAX;
+    int best_index = -1;
 
-	for (int i = 0; i < 16; i++)
-	{
-		uint8_t new_sample = prev_sample + gDeltaEncodingTable[i];
-		int error = sample > new_sample ? sample - new_sample : new_sample - sample;
+    for (int i = 0; i < 16; i++) {
+        uint8_t new_sample = prev_sample + gDeltaEncodingTable[i];
+        int error = sample > new_sample ? sample - new_sample : new_sample - sample;
 
-		if (error < best_error)
-		{
-			best_error = error;
-			best_index = i;
-		}
-	}
+        if (error < best_error) {
+            best_error = error;
+            best_index = i;
+        }
+    }
 
-	return best_index;
+    return best_index;
 }
 
-struct Bytes *delta_compress(struct Bytes *pcm)
-{
-	struct Bytes *delta = malloc(sizeof(struct Bytes));
-	// estimate the length so we can malloc
-	int num_blocks = pcm->length / 64;
-	delta->length = num_blocks * 33;
-
-	int extra = pcm->length % 64;
-	if (extra)
-	{
-		delta->length += 1;
-		extra -= 1;
-	}
-	if (extra)
-	{
-		delta->length += 1;
-		extra -= 1;
-	}
-	if (extra)
-	{
-		delta->length += (extra + 1) / 2;
-	}
-
-	delta->data = malloc(delta->length + 33);
-
-	unsigned int i = 0;
-	unsigned int j = 0;
-	int k;
-	uint8_t base;
-	int delta_index;
-
-	while (i < pcm->length)
-	{
-		base = pcm->data[i++];
-		delta->data[j++] = base;
-
-		if (i >= pcm->length)
-		{
-			break;
-		}
-		delta_index = get_delta_index(pcm->data[i++], base);
-		base += gDeltaEncodingTable[delta_index];
-		delta->data[j++] = delta_index;
-
-		for (k = 0; k < 31; k++)
-		{
-			if (i >= pcm->length)
-			{
-				break;
-			}
-			delta_index = get_delta_index(pcm->data[i++], base);
-			base += gDeltaEncodingTable[delta_index];
-			delta->data[j] = (delta_index << 4);
-
-			if (i >= pcm->length)
-			{
-				break;
-			}
-			delta_index = get_delta_index(pcm->data[i++], base);
-			base += gDeltaEncodingTable[delta_index];
-			delta->data[j++] |= delta_index;
-		}
-	}
-
-	delta->length = j;
-
-	return delta;
+struct Bytes* delta_compress(struct Bytes* pcm) {
+    struct Bytes* delta = malloc(sizeof(struct Bytes));
+    // estimate the length so we can malloc
+    int num_blocks = pcm->length / 64;
+    delta->length = num_blocks * 33;
+
+    int extra = pcm->length % 64;
+    if (extra) {
+        delta->length += 1;
+        extra -= 1;
+    }
+    if (extra) {
+        delta->length += 1;
+        extra -= 1;
+    }
+    if (extra) {
+        delta->length += (extra + 1) / 2;
+    }
+
+    delta->data = malloc(delta->length + 33);
+
+    unsigned int i = 0;
+    unsigned int j = 0;
+    int k;
+    uint8_t base;
+    int delta_index;
+
+    while (i < pcm->length) {
+        base = pcm->data[i++];
+        delta->data[j++] = base;
+
+        if (i >= pcm->length) {
+            break;
+        }
+        delta_index = get_delta_index(pcm->data[i++], base);
+        base += gDeltaEncodingTable[delta_index];
+        delta->data[j++] = delta_index;
+
+        for (k = 0; k < 31; k++) {
+            if (i >= pcm->length) {
+                break;
+            }
+            delta_index = get_delta_index(pcm->data[i++], base);
+            base += gDeltaEncodingTable[delta_index];
+            delta->data[j] = (delta_index << 4);
+
+            if (i >= pcm->length) {
+                break;
+            }
+            delta_index = get_delta_index(pcm->data[i++], base);
+            base += gDeltaEncodingTable[delta_index];
+            delta->data[j++] |= delta_index;
+        }
+    }
+
+    delta->length = j;
+
+    return delta;
 }
 
-#define STORE_U32_LE(dest, value) \
-do { \
-	*(dest) = (value) & 0xff; \
-	*((dest) + 1) = ((value) >> 8) & 0xff; \
-	*((dest) + 2) = ((value) >> 16) & 0xff; \
-	*((dest) + 3) = ((value) >> 24) & 0xff; \
-} while (0)
-
-#define LOAD_U32_LE(var, src) \
-do { \
-	(var) = *(src); \
-	(var) |= (*((src) + 1) << 8); \
-	(var) |= (*((src) + 2) << 16); \
-	(var) |= (*((src) + 3) << 24); \
-} while (0)
+#define STORE_U32_LE(dest, value)               \
+    do {                                        \
+        *(dest) = (value)&0xff;                 \
+        *((dest) + 1) = ((value) >> 8) & 0xff;  \
+        *((dest) + 2) = ((value) >> 16) & 0xff; \
+        *((dest) + 3) = ((value) >> 24) & 0xff; \
+    } while (0)
+
+#define LOAD_U32_LE(var, src)          \
+    do {                               \
+        (var) = *(src);                \
+        (var) |= (*((src) + 1) << 8);  \
+        (var) |= (*((src) + 2) << 16); \
+        (var) |= (*((src) + 3) << 24); \
+    } while (0)
 
 // Reads an .aif file and produces a .pcm file containing an array of 8-bit samples.
-void aif2pcm(const char *aif_filename, const char *pcm_filename, bool compress)
-{
-	struct Bytes *aif = read_bytearray(aif_filename);
-	AifData aif_data = {0,0,0,0,0,0,0};
-	read_aif(aif, &aif_data);
-
-	int header_size = 0x10;
-	struct Bytes *pcm;
-	struct Bytes output = {0,0};
-
-	if (compress)
-	{
-		struct Bytes *input = malloc(sizeof(struct Bytes));
-		input->data = aif_data.samples;
-		input->length = aif_data.real_num_samples;
-		pcm = delta_compress(input);
-		free(input);
-	}
-	else
-	{
-		pcm = malloc(sizeof(struct Bytes));
-		pcm->data = aif_data.samples;
-		pcm->length = aif_data.real_num_samples;
-	}
-	output.length = header_size + pcm->length;
-	output.data = malloc(output.length);
-
-	uint32_t pitch_adjust = (uint32_t)(aif_data.sample_rate * 1024);
-	uint32_t loop_offset = (uint32_t)(aif_data.loop_offset);
-	uint32_t adjusted_num_samples = (uint32_t)(aif_data.num_samples - 1);
-	uint32_t flags = 0;
-	if (aif_data.has_loop) flags |= 0x40000000;
-	if (compress) flags |= 1;
-	STORE_U32_LE(output.data + 0, flags);
-	STORE_U32_LE(output.data + 4, pitch_adjust);
-	STORE_U32_LE(output.data + 8, loop_offset);
-	STORE_U32_LE(output.data + 12, adjusted_num_samples);
-	memcpy(&output.data[header_size], pcm->data, pcm->length);
-	write_bytearray(pcm_filename, &output);
-
-	free(aif->data);
-	free(aif);
-	free(pcm);
-	free(output.data);
-	free(aif_data.samples);
+void aif2pcm(const char* aif_filename, const char* pcm_filename, bool compress) {
+    struct Bytes* aif = read_bytearray(aif_filename);
+    AifData aif_data = { 0, 0, 0, 0, 0, 0, 0 };
+    read_aif(aif, &aif_data);
+
+    int header_size = 0x10;
+    struct Bytes* pcm;
+    struct Bytes output = { 0, 0 };
+
+    if (compress) {
+        struct Bytes* input = malloc(sizeof(struct Bytes));
+        input->data = aif_data.samples;
+        input->length = aif_data.real_num_samples;
+        pcm = delta_compress(input);
+        free(input);
+    } else {
+        pcm = malloc(sizeof(struct Bytes));
+        pcm->data = aif_data.samples;
+        pcm->length = aif_data.real_num_samples;
+    }
+    output.length = header_size + pcm->length;
+    output.data = malloc(output.length);
+
+    uint32_t pitch_adjust = (uint32_t)(aif_data.sample_rate * 1024);
+    uint32_t loop_offset = (uint32_t)(aif_data.loop_offset);
+    uint32_t adjusted_num_samples = (uint32_t)(aif_data.num_samples - 1);
+    uint32_t flags = 0;
+    if (aif_data.has_loop)
+        flags |= 0x40000000;
+    if (compress)
+        flags |= 1;
+    STORE_U32_LE(output.data + 0, flags);
+    STORE_U32_LE(output.data + 4, pitch_adjust);
+    STORE_U32_LE(output.data + 8, loop_offset);
+    STORE_U32_LE(output.data + 12, adjusted_num_samples);
+    memcpy(&output.data[header_size], pcm->data, pcm->length);
+    write_bytearray(pcm_filename, &output);
+
+    free(aif->data);
+    free(aif);
+    free(pcm);
+    free(output.data);
+    free(aif_data.samples);
 }
 
 // Reads a .pcm file containing an array of 8-bit samples and produces an .aif file.
 // See http://www-mmsp.ece.mcgill.ca/documents/audioformats/aiff/Docs/AIFF-1.3.pdf for .aif file specification.
-void pcm2aif(const char *pcm_filename, const char *aif_filename, uint32_t base_note)
-{
-	struct Bytes *pcm = read_bytearray(pcm_filename);
-
-	AifData *aif_data = malloc(sizeof(AifData));
-
-	uint32_t flags;
-	LOAD_U32_LE(flags, pcm->data + 0);
-	aif_data->has_loop = flags & 0x40000000;
-	bool compressed = flags & 1;
-
-	uint32_t pitch_adjust;
-	LOAD_U32_LE(pitch_adjust, pcm->data + 4);
-	aif_data->sample_rate = pitch_adjust / 1024.0;
-
-	LOAD_U32_LE(aif_data->loop_offset, pcm->data + 8);
-	LOAD_U32_LE(aif_data->num_samples, pcm->data + 12);
-	aif_data->num_samples += 1;
-
-	if (compressed)
-	{
-		struct Bytes *delta = pcm;
-		uint8_t *pcm_data = pcm->data;
-		delta->length -= 0x10;
-		delta->data += 0x10;
-		pcm = delta_decompress(delta, aif_data->num_samples);
-		free(pcm_data);
-		free(delta);
-	}
-	else
-	{
-		pcm->length -= 0x10;
-		pcm->data += 0x10;
-	}
-
-	aif_data->samples = malloc(pcm->length);
-	memcpy(aif_data->samples, pcm->data, pcm->length);
-
-	struct Bytes *aif = malloc(sizeof(struct Bytes));
-	aif->length = 54 + 60 + pcm->length;
-	aif->data = malloc(aif->length);
-
-	long pos = 0;
-
-	// First, write the FORM header chunk.
-	// FORM Chunk ckID
-	aif->data[pos++] = 'F';
-	aif->data[pos++] = 'O';
-	aif->data[pos++] = 'R';
-	aif->data[pos++] = 'M';
-
-	// FORM Chunk ckSize
-	unsigned long form_size = pos;
-	unsigned long data_size = aif->length - 8;
-	aif->data[pos++] = ((data_size >> 24) & 0xFF);
-	aif->data[pos++] = ((data_size >> 16) & 0xFF);
-	aif->data[pos++] = ((data_size >>  8) & 0xFF);
-	aif->data[pos++] = (data_size & 0xFF);
-
-	// FORM Chunk formType
-	aif->data[pos++] = 'A';
-	aif->data[pos++] = 'I';
-	aif->data[pos++] = 'F';
-	aif->data[pos++] = 'F';
-
-	// Next, write the Common Chunk
-	// Common Chunk ckID
-	aif->data[pos++] = 'C';
-	aif->data[pos++] = 'O';
-	aif->data[pos++] = 'M';
-	aif->data[pos++] = 'M';
-
-	// Common Chunk ckSize
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 18;
-
-	// Common Chunk numChannels
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 1;  // 1 channel
-
-	// Common Chunk numSampleFrames
-	aif->data[pos++] = ((aif_data->num_samples >> 24) & 0xFF);
-	aif->data[pos++] = ((aif_data->num_samples >> 16) & 0xFF);
-	aif->data[pos++] = ((aif_data->num_samples >> 8)  & 0xFF);
-	aif->data[pos++] = (aif_data->num_samples & 0xFF);
-
-	// Common Chunk sampleSize
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 8;  // 8 bits per sample
-
-	// Common Chunk sampleRate
-	//double sample_rate = pitch_adjust / 1024.0;
-	uint8_t sample_rate_buffer[10];
-	ieee754_write_extended(aif_data->sample_rate, sample_rate_buffer);
-	for (int i = 0; i < 10; i++)
-	{
-		aif->data[pos++] = sample_rate_buffer[i];
-	}
-
-	if (aif_data->has_loop)
-	{
-
-		// Marker Chunk ckID
-		aif->data[pos++] = 'M';
-		aif->data[pos++] = 'A';
-		aif->data[pos++] = 'R';
-		aif->data[pos++] = 'K';
-
-		// Marker Chunk ckSize
-		aif->data[pos++] = 0;
-		aif->data[pos++] = 0;
-		aif->data[pos++] = 0;
-		aif->data[pos++] = 12 + (aif_data->has_loop ? 12 : 0);
-
-		// Marker Chunk numMarkers
-		aif->data[pos++] = 0;
-		aif->data[pos++] = (aif_data->has_loop ? 2 : 1);
-
-		// Marker loop start
-		aif->data[pos++] = 0;
-		aif->data[pos++] = 1;  // id = 1
-
-		long loop_start = aif_data->loop_offset;
-		aif->data[pos++] = ((loop_start >> 24) & 0xFF);
-		aif->data[pos++] = ((loop_start >> 16) & 0xFF);
-		aif->data[pos++] = ((loop_start >> 8)  & 0xFF);
-		aif->data[pos++] = (loop_start & 0xFF);  // position
-
-		aif->data[pos++] = 5;  // pascal-style string length
-		aif->data[pos++] = 'S';
-		aif->data[pos++] = 'T';
-		aif->data[pos++] = 'A';
-		aif->data[pos++] = 'R';
-		aif->data[pos++] = 'T';  // markerName
-
-		// Marker loop end
-		aif->data[pos++] = 0;
-		aif->data[pos++] = (aif_data->has_loop ? 2 : 1);  // id = 2
-
-		long loop_end = aif_data->num_samples;
-		aif->data[pos++] = ((loop_end >> 24) & 0xFF);
-		aif->data[pos++] = ((loop_end >> 16) & 0xFF);
-		aif->data[pos++] = ((loop_end >> 8)  & 0xFF);
-		aif->data[pos++] = (loop_end & 0xFF);  // position
-
-		aif->data[pos++] = 3;  // pascal-style string length
-		aif->data[pos++] = 'E';
-		aif->data[pos++] = 'N';
-		aif->data[pos++] = 'D';
-	}
-
-	// Instrument Chunk ckID
-	aif->data[pos++] = 'I';
-	aif->data[pos++] = 'N';
-	aif->data[pos++] = 'S';
-	aif->data[pos++] = 'T';
-
-	// Instrument Chunk ckSize
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 20;
-
-	aif->data[pos++] = base_note;  // baseNote
-	aif->data[pos++] = 0;          // detune
-	aif->data[pos++] = 0;          // lowNote
-	aif->data[pos++] = 127;        // highNote
-	aif->data[pos++] = 1;          // lowVelocity
-	aif->data[pos++] = 127;        // highVelocity
-	aif->data[pos++] = 0;          // gain (hi)
-	aif->data[pos++] = 0;          // gain (lo)
-
-	// Instrument Chunk sustainLoop
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 1; // playMode = ForwardLooping
-
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 1;  // beginLoop marker id
-
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 2;  // endLoop marker id
-
-		// Instrument Chunk releaseLoop
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 1; // playMode = ForwardLooping
-
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 1;  // beginLoop marker id
-
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 2;  // endLoop marker id
-
-	// Finally, write the Sound Data Chunk
-	// Sound Data Chunk ckID
-	aif->data[pos++] = 'S';
-	aif->data[pos++] = 'S';
-	aif->data[pos++] = 'N';
-	aif->data[pos++] = 'D';
-
-	// Sound Data Chunk ckSize
-	unsigned long sound_data_size = pcm->length + 8;
-	aif->data[pos++] = ((sound_data_size >> 24) & 0xFF);
-	aif->data[pos++] = ((sound_data_size >> 16) & 0xFF);
-	aif->data[pos++] = ((sound_data_size >> 8)  & 0xFF);
-	aif->data[pos++] = (sound_data_size & 0xFF);
-
-	// Sound Data Chunk offset
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-
-	// Sound Data Chunk blockSize
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-	aif->data[pos++] = 0;
-
-	// Sound Data Chunk soundData
-	for (unsigned int i = 0; i < aif_data->loop_offset; i++)
-	{
-		aif->data[pos++] = aif_data->samples[i];
-	}
-
-	int j = 0;
-	for (unsigned int i = aif_data->loop_offset; i < pcm->length; i++)
-	{
-		int pcm_index = aif_data->loop_offset + (j++ % (pcm->length - aif_data->loop_offset));
-		aif->data[pos++] = aif_data->samples[pcm_index];
-	}
-
-	aif->length = pos;
-
-	// Go back and rewrite ckSize
-	data_size = aif->length - 8;
-	aif->data[form_size + 0] = ((data_size >> 24) & 0xFF);
-	aif->data[form_size + 1] = ((data_size >> 16) & 0xFF);
-	aif->data[form_size + 2] = ((data_size >>  8) & 0xFF);
-	aif->data[form_size + 3] = (data_size & 0xFF);
-
-	write_bytearray(aif_filename, aif);
-
-	free(aif->data);
-	free(aif);
+void pcm2aif(const char* pcm_filename, const char* aif_filename, uint32_t base_note) {
+    struct Bytes* pcm = read_bytearray(pcm_filename);
+
+    AifData* aif_data = malloc(sizeof(AifData));
+
+    uint32_t flags;
+    LOAD_U32_LE(flags, pcm->data + 0);
+    aif_data->has_loop = flags & 0x40000000;
+    bool compressed = flags & 1;
+
+    uint32_t pitch_adjust;
+    LOAD_U32_LE(pitch_adjust, pcm->data + 4);
+    aif_data->sample_rate = pitch_adjust / 1024.0;
+
+    LOAD_U32_LE(aif_data->loop_offset, pcm->data + 8);
+    LOAD_U32_LE(aif_data->num_samples, pcm->data + 12);
+    aif_data->num_samples += 1;
+
+    if (compressed) {
+        struct Bytes* delta = pcm;
+        uint8_t* pcm_data = pcm->data;
+        delta->length -= 0x10;
+        delta->data += 0x10;
+        pcm = delta_decompress(delta, aif_data->num_samples);
+        free(pcm_data);
+        free(delta);
+    } else {
+        pcm->length -= 0x10;
+        pcm->data += 0x10;
+    }
+
+    aif_data->samples = malloc(pcm->length);
+    memcpy(aif_data->samples, pcm->data, pcm->length);
+
+    struct Bytes* aif = malloc(sizeof(struct Bytes));
+    aif->length = 54 + 60 + pcm->length;
+    aif->data = malloc(aif->length);
+
+    long pos = 0;
+
+    // First, write the FORM header chunk.
+    // FORM Chunk ckID
+    aif->data[pos++] = 'F';
+    aif->data[pos++] = 'O';
+    aif->data[pos++] = 'R';
+    aif->data[pos++] = 'M';
+
+    // FORM Chunk ckSize
+    unsigned long form_size = pos;
+    unsigned long data_size = aif->length - 8;
+    aif->data[pos++] = ((data_size >> 24) & 0xFF);
+    aif->data[pos++] = ((data_size >> 16) & 0xFF);
+    aif->data[pos++] = ((data_size >> 8) & 0xFF);
+    aif->data[pos++] = (data_size & 0xFF);
+
+    // FORM Chunk formType
+    aif->data[pos++] = 'A';
+    aif->data[pos++] = 'I';
+    aif->data[pos++] = 'F';
+    aif->data[pos++] = 'F';
+
+    // Next, write the Common Chunk
+    // Common Chunk ckID
+    aif->data[pos++] = 'C';
+    aif->data[pos++] = 'O';
+    aif->data[pos++] = 'M';
+    aif->data[pos++] = 'M';
+
+    // Common Chunk ckSize
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 18;
+
+    // Common Chunk numChannels
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 1; // 1 channel
+
+    // Common Chunk numSampleFrames
+    aif->data[pos++] = ((aif_data->num_samples >> 24) & 0xFF);
+    aif->data[pos++] = ((aif_data->num_samples >> 16) & 0xFF);
+    aif->data[pos++] = ((aif_data->num_samples >> 8) & 0xFF);
+    aif->data[pos++] = (aif_data->num_samples & 0xFF);
+
+    // Common Chunk sampleSize
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 8; // 8 bits per sample
+
+    // Common Chunk sampleRate
+    // double sample_rate = pitch_adjust / 1024.0;
+    uint8_t sample_rate_buffer[10];
+    ieee754_write_extended(aif_data->sample_rate, sample_rate_buffer);
+    for (int i = 0; i < 10; i++) {
+        aif->data[pos++] = sample_rate_buffer[i];
+    }
+
+    if (aif_data->has_loop) {
+
+        // Marker Chunk ckID
+        aif->data[pos++] = 'M';
+        aif->data[pos++] = 'A';
+        aif->data[pos++] = 'R';
+        aif->data[pos++] = 'K';
+
+        // Marker Chunk ckSize
+        aif->data[pos++] = 0;
+        aif->data[pos++] = 0;
+        aif->data[pos++] = 0;
+        aif->data[pos++] = 12 + (aif_data->has_loop ? 12 : 0);
+
+        // Marker Chunk numMarkers
+        aif->data[pos++] = 0;
+        aif->data[pos++] = (aif_data->has_loop ? 2 : 1);
+
+        // Marker loop start
+        aif->data[pos++] = 0;
+        aif->data[pos++] = 1; // id = 1
+
+        long loop_start = aif_data->loop_offset;
+        aif->data[pos++] = ((loop_start >> 24) & 0xFF);
+        aif->data[pos++] = ((loop_start >> 16) & 0xFF);
+        aif->data[pos++] = ((loop_start >> 8) & 0xFF);
+        aif->data[pos++] = (loop_start & 0xFF); // position
+
+        aif->data[pos++] = 5; // pascal-style string length
+        aif->data[pos++] = 'S';
+        aif->data[pos++] = 'T';
+        aif->data[pos++] = 'A';
+        aif->data[pos++] = 'R';
+        aif->data[pos++] = 'T'; // markerName
+
+        // Marker loop end
+        aif->data[pos++] = 0;
+        aif->data[pos++] = (aif_data->has_loop ? 2 : 1); // id = 2
+
+        long loop_end = aif_data->num_samples;
+        aif->data[pos++] = ((loop_end >> 24) & 0xFF);
+        aif->data[pos++] = ((loop_end >> 16) & 0xFF);
+        aif->data[pos++] = ((loop_end >> 8) & 0xFF);
+        aif->data[pos++] = (loop_end & 0xFF); // position
+
+        aif->data[pos++] = 3; // pascal-style string length
+        aif->data[pos++] = 'E';
+        aif->data[pos++] = 'N';
+        aif->data[pos++] = 'D';
+    }
+
+    // Instrument Chunk ckID
+    aif->data[pos++] = 'I';
+    aif->data[pos++] = 'N';
+    aif->data[pos++] = 'S';
+    aif->data[pos++] = 'T';
+
+    // Instrument Chunk ckSize
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 20;
+
+    aif->data[pos++] = base_note; // baseNote
+    aif->data[pos++] = 0;         // detune
+    aif->data[pos++] = 0;         // lowNote
+    aif->data[pos++] = 127;       // highNote
+    aif->data[pos++] = 1;         // lowVelocity
+    aif->data[pos++] = 127;       // highVelocity
+    aif->data[pos++] = 0;         // gain (hi)
+    aif->data[pos++] = 0;         // gain (lo)
+
+    // Instrument Chunk sustainLoop
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 1; // playMode = ForwardLooping
+
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 1; // beginLoop marker id
+
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 2; // endLoop marker id
+
+    // Instrument Chunk releaseLoop
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 1; // playMode = ForwardLooping
+
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 1; // beginLoop marker id
+
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 2; // endLoop marker id
+
+    // Finally, write the Sound Data Chunk
+    // Sound Data Chunk ckID
+    aif->data[pos++] = 'S';
+    aif->data[pos++] = 'S';
+    aif->data[pos++] = 'N';
+    aif->data[pos++] = 'D';
+
+    // Sound Data Chunk ckSize
+    unsigned long sound_data_size = pcm->length + 8;
+    aif->data[pos++] = ((sound_data_size >> 24) & 0xFF);
+    aif->data[pos++] = ((sound_data_size >> 16) & 0xFF);
+    aif->data[pos++] = ((sound_data_size >> 8) & 0xFF);
+    aif->data[pos++] = (sound_data_size & 0xFF);
+
+    // Sound Data Chunk offset
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+
+    // Sound Data Chunk blockSize
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+    aif->data[pos++] = 0;
+
+    // Sound Data Chunk soundData
+    for (unsigned int i = 0; i < aif_data->loop_offset; i++) {
+        aif->data[pos++] = aif_data->samples[i];
+    }
+
+    int j = 0;
+    for (unsigned int i = aif_data->loop_offset; i < pcm->length; i++) {
+        int pcm_index = aif_data->loop_offset + (j++ % (pcm->length - aif_data->loop_offset));
+        aif->data[pos++] = aif_data->samples[pcm_index];
+    }
+
+    aif->length = pos;
+
+    // Go back and rewrite ckSize
+    data_size = aif->length - 8;
+    aif->data[form_size + 0] = ((data_size >> 24) & 0xFF);
+    aif->data[form_size + 1] = ((data_size >> 16) & 0xFF);
+    aif->data[form_size + 2] = ((data_size >> 8) & 0xFF);
+    aif->data[form_size + 3] = (data_size & 0xFF);
+
+    write_bytearray(aif_filename, aif);
+
+    free(aif->data);
+    free(aif);
 }
 
-void usage(void)
-{
-	fprintf(stderr, "Usage: aif2pcm bin_file [aif_file]\n");
-	fprintf(stderr, "       aif2pcm aif_file [bin_file] [--compress]\n");
+void usage(void) {
+    fprintf(stderr, "Usage: aif2pcm bin_file [aif_file]\n");
+    fprintf(stderr, "       aif2pcm aif_file [bin_file] [--compress]\n");
 }
 
-int main(int argc, char **argv)
-{
-	if (argc < 2)
-	{
-		usage();
-		exit(1);
-	}
-
-	char *input_file = argv[1];
-	char *extension = get_file_extension(input_file);
-	char *output_file;
-	bool compressed = false;
-
-	if (argc > 3)
-	{
-		for (int i = 3; i < argc; i++)
-		{
-			if (strcmp(argv[i], "--compress") == 0)
-			{
-				compressed = true;
-			}
-		}
-	}
-
-	if (strcmp(extension, "aif") == 0 || strcmp(extension, "aiff") == 0)
-	{
-		if (argc >= 3)
-		{
-			output_file = argv[2];
-			aif2pcm(input_file, output_file, compressed);
-		}
-		else
-		{
-			output_file = new_file_extension(input_file, "bin");
-			aif2pcm(input_file, output_file, compressed);
-			free(output_file);
-		}
-	}
-	else if (strcmp(extension, "bin") == 0)
-	{
-		if (argc >= 3)
-		{
-			output_file = argv[2];
-			pcm2aif(input_file, output_file, 60);
-		}
-		else
-		{
-			output_file = new_file_extension(input_file, "aif");
-			pcm2aif(input_file, output_file, 60);
-			free(output_file);
-		}
-	}
-	else
-	{
-		FATAL_ERROR("Input file must be .aif or .bin: '%s'\n", input_file);
-	}
-
-	return 0;
+int main(int argc, char** argv) {
+    if (argc < 2) {
+        usage();
+        exit(1);
+    }
+
+    char* input_file = argv[1];
+    char* extension = get_file_extension(input_file);
+    char* output_file;
+    bool compressed = false;
+
+    if (argc > 3) {
+        for (int i = 3; i < argc; i++) {
+            if (strcmp(argv[i], "--compress") == 0) {
+                compressed = true;
+            }
+        }
+    }
+
+    if (strcmp(extension, "aif") == 0 || strcmp(extension, "aiff") == 0) {
+        if (argc >= 3) {
+            output_file = argv[2];
+            aif2pcm(input_file, output_file, compressed);
+        } else {
+            output_file = new_file_extension(input_file, "bin");
+            aif2pcm(input_file, output_file, compressed);
+            free(output_file);
+        }
+    } else if (strcmp(extension, "bin") == 0) {
+        if (argc >= 3) {
+            output_file = argv[2];
+            pcm2aif(input_file, output_file, 60);
+        } else {
+            output_file = new_file_extension(input_file, "aif");
+            pcm2aif(input_file, output_file, 60);
+            free(output_file);
+        }
+    } else {
+        FATAL_ERROR("Input file must be .aif or .bin: '%s'\n", input_file);
+    }
+
+    return 0;
 }
diff --git a/tools/src/asset_processor/offsets.cpp b/tools/src/asset_processor/offsets.cpp
index 45d991a3..48ed4139 100644
--- a/tools/src/asset_processor/offsets.cpp
+++ b/tools/src/asset_processor/offsets.cpp
@@ -1,6 +1,6 @@
 #include "offsets.h"
 
-OffsetCalculator::OffsetCalculator(std::filesystem::path outputFile, int baseOffset): baseOffset(baseOffset) {
+OffsetCalculator::OffsetCalculator(std::filesystem::path outputFile, int baseOffset) : baseOffset(baseOffset) {
     output = std::ofstream(outputFile);
 }
 
diff --git a/tools/src/asset_processor/offsets.h b/tools/src/asset_processor/offsets.h
index 2130f6cb..bf9fef4e 100644
--- a/tools/src/asset_processor/offsets.h
+++ b/tools/src/asset_processor/offsets.h
@@ -6,11 +6,11 @@
 
 class OffsetCalculator {
 
-public:
+  public:
     OffsetCalculator(std::filesystem::path offsetsFile, int baseOffset);
     void addAsset(int start, std::string symbol);
 
-private:
+  private:
     std::ofstream output;
     int baseOffset;
 };
diff --git a/tools/src/bin2c/bin2c.c b/tools/src/bin2c/bin2c.c
index b4bd437f..18d2fd27 100755..100644
--- a/tools/src/bin2c/bin2c.c
+++ b/tools/src/bin2c/bin2c.c
@@ -25,27 +25,24 @@
 
 #ifdef _MSC_VER
 
-#define FATAL_ERROR(format, ...)          \
-do                                        \
-{                                         \
-    fprintf(stderr, format, __VA_ARGS__); \
-    exit(1);                              \
-} while (0)
+#define FATAL_ERROR(format, ...)              \
+    do {                                      \
+        fprintf(stderr, format, __VA_ARGS__); \
+        exit(1);                              \
+    } while (0)
 
 #else
 
-#define FATAL_ERROR(format, ...)            \
-do                                          \
-{                                           \
-    fprintf(stderr, format, ##__VA_ARGS__); \
-    exit(1);                                \
-} while (0)
+#define FATAL_ERROR(format, ...)                \
+    do {                                        \
+        fprintf(stderr, format, ##__VA_ARGS__); \
+        exit(1);                                \
+    } while (0)
 
 #endif // _MSC_VER
 
-unsigned char *ReadWholeFile(char *path, int *size)
-{
-    FILE *fp = fopen(path, "rb");
+unsigned char* ReadWholeFile(char* path, int* size) {
+    FILE* fp = fopen(path, "rb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open \"%s\" for reading.\n", path);
@@ -54,7 +51,7 @@ unsigned char *ReadWholeFile(char *path, int *size)
 
     *size = ftell(fp);
 
-    unsigned char *buffer = malloc(*size);
+    unsigned char* buffer = malloc(*size);
 
     if (buffer == NULL)
         FATAL_ERROR("Failed to allocate memory for reading \"%s\".\n", path);
@@ -69,33 +66,26 @@ unsigned char *ReadWholeFile(char *path, int *size)
     return buffer;
 }
 
-int ExtractData(unsigned char *buffer, int offset, int size)
-{
-    switch (size)
-    {
-    case 1:
-        return buffer[offset];
-    case 2:
-        return (buffer[offset + 1] << 8)
-             | buffer[offset];
-    case 4:
-        return (buffer[offset + 3] << 24)
-             | (buffer[offset + 2] << 16)
-             | (buffer[offset + 1] << 8)
-             | buffer[offset];
-    default:
-        FATAL_ERROR("Invalid size passed to ExtractData.\n");
+int ExtractData(unsigned char* buffer, int offset, int size) {
+    switch (size) {
+        case 1:
+            return buffer[offset];
+        case 2:
+            return (buffer[offset + 1] << 8) | buffer[offset];
+        case 4:
+            return (buffer[offset + 3] << 24) | (buffer[offset + 2] << 16) | (buffer[offset + 1] << 8) | buffer[offset];
+        default:
+            FATAL_ERROR("Invalid size passed to ExtractData.\n");
     }
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char** argv) {
     if (argc < 3)
         FATAL_ERROR("Usage: bin2c INPUT_FILE VAR_NAME [OPTIONS...]\n");
 
     int fileSize;
-    unsigned char *buffer = ReadWholeFile(argv[1], &fileSize);
-    char *var_name = argv[2];
+    unsigned char* buffer = ReadWholeFile(argv[1], &fileSize);
+    char* var_name = argv[2];
     int col = 1;
     int pad = 0;
     int size = 1;
@@ -103,28 +93,22 @@ int main(int argc, char **argv)
     bool isStatic = false;
     bool isDecimal = false;
 
-    for (int i = 3; i < argc; i++)
-    {
-        if (!strcmp(argv[i], "-col"))
-        {
+    for (int i = 3; i < argc; i++) {
+        if (!strcmp(argv[i], "-col")) {
             i++;
 
             if (i >= argc)
                 FATAL_ERROR("Missing argument after '-col'.\n");
 
             col = atoi(argv[i]);
-        }
-        else if (!strcmp(argv[i], "-pad"))
-        {
+        } else if (!strcmp(argv[i], "-pad")) {
             i++;
 
             if (i >= argc)
                 FATAL_ERROR("Missing argument after '-pad'.\n");
 
             pad = atoi(argv[i]);
-        }
-        else if (!strcmp(argv[i], "-size"))
-        {
+        } else if (!strcmp(argv[i], "-size")) {
             i++;
 
             if (i >= argc)
@@ -134,22 +118,14 @@ int main(int argc, char **argv)
 
             if (size != 1 && size != 2 && size != 4)
                 FATAL_ERROR("Size must be 1, 2, or 4.\n");
-        }
-        else if (!strcmp(argv[i], "-signed"))
-        {
+        } else if (!strcmp(argv[i], "-signed")) {
             isSigned = true;
             isDecimal = true;
-        }
-        else if (!strcmp(argv[i], "-static"))
-        {
+        } else if (!strcmp(argv[i], "-static")) {
             isStatic = true;
-        }
-        else if (!strcmp(argv[i], "-decimal"))
-        {
+        } else if (!strcmp(argv[i], "-decimal")) {
             isDecimal = true;
-        }
-        else
-        {
+        } else {
             FATAL_ERROR("Unrecognized option '%s'.\n", argv[i]);
         }
     }
@@ -174,23 +150,19 @@ int main(int argc, char **argv)
     int count = fileSize / size;
     int offset = 0;
 
-    for (int i = 0; i < count; i++)
-    {
+    for (int i = 0; i < count; i++) {
         if (i % col == 0)
             printf("\n    ");
 
         int data = ExtractData(buffer, offset, size);
         offset += size;
 
-        if (isDecimal)
-        {
+        if (isDecimal) {
             if (isSigned)
                 printf("%*d, ", pad, data);
             else
                 printf("%*uu, ", pad, data);
-        }
-        else
-        {
+        } else {
             printf("%#*xu, ", pad, data);
         }
     }
diff --git a/tools/src/gbafix/elf.h b/tools/src/gbafix/elf.h
index 79d3b974..73592286 100755..100644
--- a/tools/src/gbafix/elf.h
+++ b/tools/src/gbafix/elf.h
@@ -36,14 +36,14 @@ typedef uint16_t Elf32_Half;
 typedef uint16_t Elf64_Half;
 
 typedef uint32_t Elf32_Word;
-typedef	int32_t  Elf32_Sword;
+typedef int32_t Elf32_Sword;
 typedef uint32_t Elf64_Word;
-typedef	int32_t  Elf64_Sword;
+typedef int32_t Elf64_Sword;
 
 typedef uint64_t Elf32_Xword;
-typedef	int64_t  Elf32_Sxword;
+typedef int64_t Elf32_Sxword;
 typedef uint64_t Elf64_Xword;
-typedef	int64_t  Elf64_Sxword;
+typedef int64_t Elf64_Sxword;
 
 typedef uint32_t Elf32_Addr;
 typedef uint64_t Elf64_Addr;
@@ -60,1526 +60,1385 @@ typedef Elf64_Half Elf64_Versym;
 #define EI_NIDENT (16)
 
 typedef struct {
-  unsigned char	e_ident[EI_NIDENT];
-  Elf32_Half	e_type;
-  Elf32_Half	e_machine;
-  Elf32_Word	e_version;
-  Elf32_Addr	e_entry;
-  Elf32_Off	e_phoff;
-  Elf32_Off	e_shoff;
-  Elf32_Word	e_flags;
-  Elf32_Half	e_ehsize;
-  Elf32_Half	e_phentsize;
-  Elf32_Half	e_phnum;
-  Elf32_Half	e_shentsize;
-  Elf32_Half	e_shnum;
-  Elf32_Half	e_shstrndx;
+    unsigned char e_ident[EI_NIDENT];
+    Elf32_Half e_type;
+    Elf32_Half e_machine;
+    Elf32_Word e_version;
+    Elf32_Addr e_entry;
+    Elf32_Off e_phoff;
+    Elf32_Off e_shoff;
+    Elf32_Word e_flags;
+    Elf32_Half e_ehsize;
+    Elf32_Half e_phentsize;
+    Elf32_Half e_phnum;
+    Elf32_Half e_shentsize;
+    Elf32_Half e_shnum;
+    Elf32_Half e_shstrndx;
 } Elf32_Ehdr;
 
 typedef struct {
-  unsigned char	e_ident[EI_NIDENT];
-  Elf64_Half	e_type;
-  Elf64_Half	e_machine;
-  Elf64_Word	e_version;
-  Elf64_Addr	e_entry;
-  Elf64_Off	e_phoff;
-  Elf64_Off	e_shoff;
-  Elf64_Word	e_flags;
-  Elf64_Half	e_ehsize;
-  Elf64_Half	e_phentsize;
-  Elf64_Half	e_phnum;
-  Elf64_Half	e_shentsize;
-  Elf64_Half	e_shnum;
-  Elf64_Half	e_shstrndx;
+    unsigned char e_ident[EI_NIDENT];
+    Elf64_Half e_type;
+    Elf64_Half e_machine;
+    Elf64_Word e_version;
+    Elf64_Addr e_entry;
+    Elf64_Off e_phoff;
+    Elf64_Off e_shoff;
+    Elf64_Word e_flags;
+    Elf64_Half e_ehsize;
+    Elf64_Half e_phentsize;
+    Elf64_Half e_phnum;
+    Elf64_Half e_shentsize;
+    Elf64_Half e_shnum;
+    Elf64_Half e_shstrndx;
 } Elf64_Ehdr;
 
-#define EI_MAG0		0
-#define ELFMAG0		0x7f
-
-#define EI_MAG1		1
-#define ELFMAG1		'E'
-
-#define EI_MAG2		2
-#define ELFMAG2		'L'
-
-#define EI_MAG3		3
-#define ELFMAG3		'F'
-
-
-#define	ELFMAG		"\177ELF"
-#define	SELFMAG		4
-
-#define EI_CLASS	4
-#define ELFCLASSNONE	0
-#define ELFCLASS32	1
-#define ELFCLASS64	2
-#define ELFCLASSNUM	3
-
-#define EI_DATA		5
-#define ELFDATANONE	0
-#define ELFDATA2LSB	1
-#define ELFDATA2MSB	2
-#define ELFDATANUM	3
-
-#define EI_VERSION	6
-
-
-#define EI_OSABI	7
-#define ELFOSABI_NONE		0
-#define ELFOSABI_SYSV		0
-#define ELFOSABI_HPUX		1
-#define ELFOSABI_NETBSD		2
-#define ELFOSABI_LINUX		3
-#define ELFOSABI_GNU		3
-#define ELFOSABI_SOLARIS	6
-#define ELFOSABI_AIX		7
-#define ELFOSABI_IRIX		8
-#define ELFOSABI_FREEBSD	9
-#define ELFOSABI_TRU64		10
-#define ELFOSABI_MODESTO	11
-#define ELFOSABI_OPENBSD	12
-#define ELFOSABI_ARM		97
-#define ELFOSABI_STANDALONE	255
-
-#define EI_ABIVERSION	8
-
-#define EI_PAD		9
-
-
-
-#define ET_NONE		0
-#define ET_REL		1
-#define ET_EXEC		2
-#define ET_DYN		3
-#define ET_CORE		4
-#define	ET_NUM		5
-#define ET_LOOS		0xfe00
-#define ET_HIOS		0xfeff
-#define ET_LOPROC	0xff00
-#define ET_HIPROC	0xffff
-
-
-
-#define EM_NONE		 0
-#define EM_M32		 1
-#define EM_SPARC	 2
-#define EM_386		 3
-#define EM_68K		 4
-#define EM_88K		 5
-#define EM_860		 7
-#define EM_MIPS		 8
-#define EM_S370		 9
-#define EM_MIPS_RS3_LE	10
-
-#define EM_PARISC	15
-#define EM_VPP500	17
-#define EM_SPARC32PLUS	18
-#define EM_960		19
-#define EM_PPC		20
-#define EM_PPC64	21
-#define EM_S390		22
-
-#define EM_V800		36
-#define EM_FR20		37
-#define EM_RH32		38
-#define EM_RCE		39
-#define EM_ARM		40
-#define EM_FAKE_ALPHA	41
-#define EM_SH		42
-#define EM_SPARCV9	43
-#define EM_TRICORE	44
-#define EM_ARC		45
-#define EM_H8_300	46
-#define EM_H8_300H	47
-#define EM_H8S		48
-#define EM_H8_500	49
-#define EM_IA_64	50
-#define EM_MIPS_X	51
-#define EM_COLDFIRE	52
-#define EM_68HC12	53
-#define EM_MMA		54
-#define EM_PCP		55
-#define EM_NCPU		56
-#define EM_NDR1		57
-#define EM_STARCORE	58
-#define EM_ME16		59
-#define EM_ST100	60
-#define EM_TINYJ	61
-#define EM_X86_64	62
-#define EM_PDSP		63
-
-#define EM_FX66		66
-#define EM_ST9PLUS	67
-#define EM_ST7		68
-#define EM_68HC16	69
-#define EM_68HC11	70
-#define EM_68HC08	71
-#define EM_68HC05	72
-#define EM_SVX		73
-#define EM_ST19		74
-#define EM_VAX		75
-#define EM_CRIS		76
-#define EM_JAVELIN	77
-#define EM_FIREPATH	78
-#define EM_ZSP		79
-#define EM_MMIX		80
-#define EM_HUANY	81
-#define EM_PRISM	82
-#define EM_AVR		83
-#define EM_FR30		84
-#define EM_D10V		85
-#define EM_D30V		86
-#define EM_V850		87
-#define EM_M32R		88
-#define EM_MN10300	89
-#define EM_MN10200	90
-#define EM_PJ		91
-#define EM_OR1K		92
-#define EM_OPENRISC	92
-#define EM_ARC_A5	93
-#define EM_ARC_COMPACT	93
-#define EM_XTENSA	94
-#define EM_VIDEOCORE	95
-#define EM_TMM_GPP	96
-#define EM_NS32K	97
-#define EM_TPC		98
-#define EM_SNP1K	99
-#define EM_ST200	100
-#define EM_IP2K		101
-#define EM_MAX		102
-#define EM_CR		103
-#define EM_F2MC16	104
-#define EM_MSP430	105
-#define EM_BLACKFIN	106
-#define EM_SE_C33	107
-#define EM_SEP		108
-#define EM_ARCA		109
-#define EM_UNICORE	110
-#define EM_EXCESS	111
-#define EM_DXP		112
+#define EI_MAG0 0
+#define ELFMAG0 0x7f
+
+#define EI_MAG1 1
+#define ELFMAG1 'E'
+
+#define EI_MAG2 2
+#define ELFMAG2 'L'
+
+#define EI_MAG3 3
+#define ELFMAG3 'F'
+
+#define ELFMAG "\177ELF"
+#define SELFMAG 4
+
+#define EI_CLASS 4
+#define ELFCLASSNONE 0
+#define ELFCLASS32 1
+#define ELFCLASS64 2
+#define ELFCLASSNUM 3
+
+#define EI_DATA 5
+#define ELFDATANONE 0
+#define ELFDATA2LSB 1
+#define ELFDATA2MSB 2
+#define ELFDATANUM 3
+
+#define EI_VERSION 6
+
+#define EI_OSABI 7
+#define ELFOSABI_NONE 0
+#define ELFOSABI_SYSV 0
+#define ELFOSABI_HPUX 1
+#define ELFOSABI_NETBSD 2
+#define ELFOSABI_LINUX 3
+#define ELFOSABI_GNU 3
+#define ELFOSABI_SOLARIS 6
+#define ELFOSABI_AIX 7
+#define ELFOSABI_IRIX 8
+#define ELFOSABI_FREEBSD 9
+#define ELFOSABI_TRU64 10
+#define ELFOSABI_MODESTO 11
+#define ELFOSABI_OPENBSD 12
+#define ELFOSABI_ARM 97
+#define ELFOSABI_STANDALONE 255
+
+#define EI_ABIVERSION 8
+
+#define EI_PAD 9
+
+#define ET_NONE 0
+#define ET_REL 1
+#define ET_EXEC 2
+#define ET_DYN 3
+#define ET_CORE 4
+#define ET_NUM 5
+#define ET_LOOS 0xfe00
+#define ET_HIOS 0xfeff
+#define ET_LOPROC 0xff00
+#define ET_HIPROC 0xffff
+
+#define EM_NONE 0
+#define EM_M32 1
+#define EM_SPARC 2
+#define EM_386 3
+#define EM_68K 4
+#define EM_88K 5
+#define EM_860 7
+#define EM_MIPS 8
+#define EM_S370 9
+#define EM_MIPS_RS3_LE 10
+
+#define EM_PARISC 15
+#define EM_VPP500 17
+#define EM_SPARC32PLUS 18
+#define EM_960 19
+#define EM_PPC 20
+#define EM_PPC64 21
+#define EM_S390 22
+
+#define EM_V800 36
+#define EM_FR20 37
+#define EM_RH32 38
+#define EM_RCE 39
+#define EM_ARM 40
+#define EM_FAKE_ALPHA 41
+#define EM_SH 42
+#define EM_SPARCV9 43
+#define EM_TRICORE 44
+#define EM_ARC 45
+#define EM_H8_300 46
+#define EM_H8_300H 47
+#define EM_H8S 48
+#define EM_H8_500 49
+#define EM_IA_64 50
+#define EM_MIPS_X 51
+#define EM_COLDFIRE 52
+#define EM_68HC12 53
+#define EM_MMA 54
+#define EM_PCP 55
+#define EM_NCPU 56
+#define EM_NDR1 57
+#define EM_STARCORE 58
+#define EM_ME16 59
+#define EM_ST100 60
+#define EM_TINYJ 61
+#define EM_X86_64 62
+#define EM_PDSP 63
+
+#define EM_FX66 66
+#define EM_ST9PLUS 67
+#define EM_ST7 68
+#define EM_68HC16 69
+#define EM_68HC11 70
+#define EM_68HC08 71
+#define EM_68HC05 72
+#define EM_SVX 73
+#define EM_ST19 74
+#define EM_VAX 75
+#define EM_CRIS 76
+#define EM_JAVELIN 77
+#define EM_FIREPATH 78
+#define EM_ZSP 79
+#define EM_MMIX 80
+#define EM_HUANY 81
+#define EM_PRISM 82
+#define EM_AVR 83
+#define EM_FR30 84
+#define EM_D10V 85
+#define EM_D30V 86
+#define EM_V850 87
+#define EM_M32R 88
+#define EM_MN10300 89
+#define EM_MN10200 90
+#define EM_PJ 91
+#define EM_OR1K 92
+#define EM_OPENRISC 92
+#define EM_ARC_A5 93
+#define EM_ARC_COMPACT 93
+#define EM_XTENSA 94
+#define EM_VIDEOCORE 95
+#define EM_TMM_GPP 96
+#define EM_NS32K 97
+#define EM_TPC 98
+#define EM_SNP1K 99
+#define EM_ST200 100
+#define EM_IP2K 101
+#define EM_MAX 102
+#define EM_CR 103
+#define EM_F2MC16 104
+#define EM_MSP430 105
+#define EM_BLACKFIN 106
+#define EM_SE_C33 107
+#define EM_SEP 108
+#define EM_ARCA 109
+#define EM_UNICORE 110
+#define EM_EXCESS 111
+#define EM_DXP 112
 #define EM_ALTERA_NIOS2 113
-#define EM_CRX		114
-#define EM_XGATE	115
-#define EM_C166		116
-#define EM_M16C		117
-#define EM_DSPIC30F	118
-#define EM_CE		119
-#define EM_M32C		120
-#define EM_TSK3000	131
-#define EM_RS08		132
-#define EM_SHARC	133
-#define EM_ECOG2	134
-#define EM_SCORE7	135
-#define EM_DSP24	136
-#define EM_VIDEOCORE3	137
+#define EM_CRX 114
+#define EM_XGATE 115
+#define EM_C166 116
+#define EM_M16C 117
+#define EM_DSPIC30F 118
+#define EM_CE 119
+#define EM_M32C 120
+#define EM_TSK3000 131
+#define EM_RS08 132
+#define EM_SHARC 133
+#define EM_ECOG2 134
+#define EM_SCORE7 135
+#define EM_DSP24 136
+#define EM_VIDEOCORE3 137
 #define EM_LATTICEMICO32 138
-#define EM_SE_C17	139
-#define EM_TI_C6000	140
-#define EM_TI_C2000	141
-#define EM_TI_C5500	142
-#define EM_TI_ARP32	143
-#define EM_TI_PRU	144
-#define EM_MMDSP_PLUS	160
-#define EM_CYPRESS_M8C	161
-#define EM_R32C		162
-#define EM_TRIMEDIA	163
-#define EM_QDSP6	164
-#define EM_8051		165
-#define EM_STXP7X	166
-#define EM_NDS32	167
-#define EM_ECOG1X	168
-#define EM_MAXQ30	169
-#define EM_XIMO16	170
-#define EM_MANIK	171
-#define EM_CRAYNV2	172
-#define EM_RX		173
-#define EM_METAG	174
-#define EM_MCST_ELBRUS	175
-#define EM_ECOG16	176
-#define EM_CR16		177
-#define EM_ETPU		178
-#define EM_SLE9X	179
-#define EM_L10M		180
-#define EM_K10M		181
-#define EM_AARCH64	183
-#define EM_AVR32	185
-#define EM_STM8		186
-#define EM_TILE64	187
-#define EM_TILEPRO	188
-#define EM_MICROBLAZE	189
-#define EM_CUDA		190
-#define EM_TILEGX	191
-#define EM_CLOUDSHIELD	192
-#define EM_COREA_1ST	193
-#define EM_COREA_2ND	194
-#define EM_ARC_COMPACT2	195
-#define EM_OPEN8	196
-#define EM_RL78		197
-#define EM_VIDEOCORE5	198
-#define EM_78KOR	199
-#define EM_56800EX	200
-#define EM_BA1		201
-#define EM_BA2		202
-#define EM_XCORE	203
-#define EM_MCHP_PIC	204
-#define EM_KM32		210
-#define EM_KMX32	211
-#define EM_EMX16	212
-#define EM_EMX8		213
-#define EM_KVARC	214
-#define EM_CDP		215
-#define EM_COGE		216
-#define EM_COOL		217
-#define EM_NORC		218
-#define EM_CSR_KALIMBA	219
-#define EM_Z80		220
-#define EM_VISIUM	221
-#define EM_FT32		222
-#define EM_MOXIE	223
-#define EM_AMDGPU	224
-#define EM_RISCV	243
-#define EM_BPF		247
-#define EM_NUM		248
-
-#define EM_ALPHA	0x9026
-
-#define EV_NONE		0
-#define EV_CURRENT	1
-#define EV_NUM		2
+#define EM_SE_C17 139
+#define EM_TI_C6000 140
+#define EM_TI_C2000 141
+#define EM_TI_C5500 142
+#define EM_TI_ARP32 143
+#define EM_TI_PRU 144
+#define EM_MMDSP_PLUS 160
+#define EM_CYPRESS_M8C 161
+#define EM_R32C 162
+#define EM_TRIMEDIA 163
+#define EM_QDSP6 164
+#define EM_8051 165
+#define EM_STXP7X 166
+#define EM_NDS32 167
+#define EM_ECOG1X 168
+#define EM_MAXQ30 169
+#define EM_XIMO16 170
+#define EM_MANIK 171
+#define EM_CRAYNV2 172
+#define EM_RX 173
+#define EM_METAG 174
+#define EM_MCST_ELBRUS 175
+#define EM_ECOG16 176
+#define EM_CR16 177
+#define EM_ETPU 178
+#define EM_SLE9X 179
+#define EM_L10M 180
+#define EM_K10M 181
+#define EM_AARCH64 183
+#define EM_AVR32 185
+#define EM_STM8 186
+#define EM_TILE64 187
+#define EM_TILEPRO 188
+#define EM_MICROBLAZE 189
+#define EM_CUDA 190
+#define EM_TILEGX 191
+#define EM_CLOUDSHIELD 192
+#define EM_COREA_1ST 193
+#define EM_COREA_2ND 194
+#define EM_ARC_COMPACT2 195
+#define EM_OPEN8 196
+#define EM_RL78 197
+#define EM_VIDEOCORE5 198
+#define EM_78KOR 199
+#define EM_56800EX 200
+#define EM_BA1 201
+#define EM_BA2 202
+#define EM_XCORE 203
+#define EM_MCHP_PIC 204
+#define EM_KM32 210
+#define EM_KMX32 211
+#define EM_EMX16 212
+#define EM_EMX8 213
+#define EM_KVARC 214
+#define EM_CDP 215
+#define EM_COGE 216
+#define EM_COOL 217
+#define EM_NORC 218
+#define EM_CSR_KALIMBA 219
+#define EM_Z80 220
+#define EM_VISIUM 221
+#define EM_FT32 222
+#define EM_MOXIE 223
+#define EM_AMDGPU 224
+#define EM_RISCV 243
+#define EM_BPF 247
+#define EM_NUM 248
+
+#define EM_ALPHA 0x9026
+
+#define EV_NONE 0
+#define EV_CURRENT 1
+#define EV_NUM 2
 
 typedef struct {
-  Elf32_Word	sh_name;
-  Elf32_Word	sh_type;
-  Elf32_Word	sh_flags;
-  Elf32_Addr	sh_addr;
-  Elf32_Off	sh_offset;
-  Elf32_Word	sh_size;
-  Elf32_Word	sh_link;
-  Elf32_Word	sh_info;
-  Elf32_Word	sh_addralign;
-  Elf32_Word	sh_entsize;
+    Elf32_Word sh_name;
+    Elf32_Word sh_type;
+    Elf32_Word sh_flags;
+    Elf32_Addr sh_addr;
+    Elf32_Off sh_offset;
+    Elf32_Word sh_size;
+    Elf32_Word sh_link;
+    Elf32_Word sh_info;
+    Elf32_Word sh_addralign;
+    Elf32_Word sh_entsize;
 } Elf32_Shdr;
 
 typedef struct {
-  Elf64_Word	sh_name;
-  Elf64_Word	sh_type;
-  Elf64_Xword	sh_flags;
-  Elf64_Addr	sh_addr;
-  Elf64_Off	sh_offset;
-  Elf64_Xword	sh_size;
-  Elf64_Word	sh_link;
-  Elf64_Word	sh_info;
-  Elf64_Xword	sh_addralign;
-  Elf64_Xword	sh_entsize;
+    Elf64_Word sh_name;
+    Elf64_Word sh_type;
+    Elf64_Xword sh_flags;
+    Elf64_Addr sh_addr;
+    Elf64_Off sh_offset;
+    Elf64_Xword sh_size;
+    Elf64_Word sh_link;
+    Elf64_Word sh_info;
+    Elf64_Xword sh_addralign;
+    Elf64_Xword sh_entsize;
 } Elf64_Shdr;
 
-
-
-#define SHN_UNDEF	0
-#define SHN_LORESERVE	0xff00
-#define SHN_LOPROC	0xff00
-#define SHN_BEFORE	0xff00
-
-#define SHN_AFTER	0xff01
-
-#define SHN_HIPROC	0xff1f
-#define SHN_LOOS	0xff20
-#define SHN_HIOS	0xff3f
-#define SHN_ABS		0xfff1
-#define SHN_COMMON	0xfff2
-#define SHN_XINDEX	0xffff
-#define SHN_HIRESERVE	0xffff
-
-
-
-#define SHT_NULL	  0
-#define SHT_PROGBITS	  1
-#define SHT_SYMTAB	  2
-#define SHT_STRTAB	  3
-#define SHT_RELA	  4
-#define SHT_HASH	  5
-#define SHT_DYNAMIC	  6
-#define SHT_NOTE	  7
-#define SHT_NOBITS	  8
-#define SHT_REL		  9
-#define SHT_SHLIB	  10
-#define SHT_DYNSYM	  11
-#define SHT_INIT_ARRAY	  14
-#define SHT_FINI_ARRAY	  15
+#define SHN_UNDEF 0
+#define SHN_LORESERVE 0xff00
+#define SHN_LOPROC 0xff00
+#define SHN_BEFORE 0xff00
+
+#define SHN_AFTER 0xff01
+
+#define SHN_HIPROC 0xff1f
+#define SHN_LOOS 0xff20
+#define SHN_HIOS 0xff3f
+#define SHN_ABS 0xfff1
+#define SHN_COMMON 0xfff2
+#define SHN_XINDEX 0xffff
+#define SHN_HIRESERVE 0xffff
+
+#define SHT_NULL 0
+#define SHT_PROGBITS 1
+#define SHT_SYMTAB 2
+#define SHT_STRTAB 3
+#define SHT_RELA 4
+#define SHT_HASH 5
+#define SHT_DYNAMIC 6
+#define SHT_NOTE 7
+#define SHT_NOBITS 8
+#define SHT_REL 9
+#define SHT_SHLIB 10
+#define SHT_DYNSYM 11
+#define SHT_INIT_ARRAY 14
+#define SHT_FINI_ARRAY 15
 #define SHT_PREINIT_ARRAY 16
-#define SHT_GROUP	  17
-#define SHT_SYMTAB_SHNDX  18
-#define	SHT_NUM		  19
-#define SHT_LOOS	  0x60000000
+#define SHT_GROUP 17
+#define SHT_SYMTAB_SHNDX 18
+#define SHT_NUM 19
+#define SHT_LOOS 0x60000000
 #define SHT_GNU_ATTRIBUTES 0x6ffffff5
-#define SHT_GNU_HASH	  0x6ffffff6
-#define SHT_GNU_LIBLIST	  0x6ffffff7
-#define SHT_CHECKSUM	  0x6ffffff8
-#define SHT_LOSUNW	  0x6ffffffa
-#define SHT_SUNW_move	  0x6ffffffa
-#define SHT_SUNW_COMDAT   0x6ffffffb
-#define SHT_SUNW_syminfo  0x6ffffffc
-#define SHT_GNU_verdef	  0x6ffffffd
-#define SHT_GNU_verneed	  0x6ffffffe
-#define SHT_GNU_versym	  0x6fffffff
-#define SHT_HISUNW	  0x6fffffff
-#define SHT_HIOS	  0x6fffffff
-#define SHT_LOPROC	  0x70000000
-#define SHT_HIPROC	  0x7fffffff
-#define SHT_LOUSER	  0x80000000
-#define SHT_HIUSER	  0x8fffffff
-
-#define SHF_WRITE	     (1 << 0)
-#define SHF_ALLOC	     (1 << 1)
-#define SHF_EXECINSTR	     (1 << 2)
-#define SHF_MERGE	     (1 << 4)
-#define SHF_STRINGS	     (1 << 5)
-#define SHF_INFO_LINK	     (1 << 6)
-#define SHF_LINK_ORDER	     (1 << 7)
+#define SHT_GNU_HASH 0x6ffffff6
+#define SHT_GNU_LIBLIST 0x6ffffff7
+#define SHT_CHECKSUM 0x6ffffff8
+#define SHT_LOSUNW 0x6ffffffa
+#define SHT_SUNW_move 0x6ffffffa
+#define SHT_SUNW_COMDAT 0x6ffffffb
+#define SHT_SUNW_syminfo 0x6ffffffc
+#define SHT_GNU_verdef 0x6ffffffd
+#define SHT_GNU_verneed 0x6ffffffe
+#define SHT_GNU_versym 0x6fffffff
+#define SHT_HISUNW 0x6fffffff
+#define SHT_HIOS 0x6fffffff
+#define SHT_LOPROC 0x70000000
+#define SHT_HIPROC 0x7fffffff
+#define SHT_LOUSER 0x80000000
+#define SHT_HIUSER 0x8fffffff
+
+#define SHF_WRITE (1 << 0)
+#define SHF_ALLOC (1 << 1)
+#define SHF_EXECINSTR (1 << 2)
+#define SHF_MERGE (1 << 4)
+#define SHF_STRINGS (1 << 5)
+#define SHF_INFO_LINK (1 << 6)
+#define SHF_LINK_ORDER (1 << 7)
 #define SHF_OS_NONCONFORMING (1 << 8)
 
-#define SHF_GROUP	     (1 << 9)
-#define SHF_TLS		     (1 << 10)
-#define SHF_COMPRESSED	     (1 << 11)
-#define SHF_MASKOS	     0x0ff00000
-#define SHF_MASKPROC	     0xf0000000
-#define SHF_ORDERED	     (1 << 30)
-#define SHF_EXCLUDE	     (1U << 31)
+#define SHF_GROUP (1 << 9)
+#define SHF_TLS (1 << 10)
+#define SHF_COMPRESSED (1 << 11)
+#define SHF_MASKOS 0x0ff00000
+#define SHF_MASKPROC 0xf0000000
+#define SHF_ORDERED (1 << 30)
+#define SHF_EXCLUDE (1U << 31)
 
 typedef struct {
-  Elf32_Word	ch_type;
-  Elf32_Word	ch_size;
-  Elf32_Word	ch_addralign;
+    Elf32_Word ch_type;
+    Elf32_Word ch_size;
+    Elf32_Word ch_addralign;
 } Elf32_Chdr;
 
 typedef struct {
-  Elf64_Word	ch_type;
-  Elf64_Word	ch_reserved;
-  Elf64_Xword	ch_size;
-  Elf64_Xword	ch_addralign;
+    Elf64_Word ch_type;
+    Elf64_Word ch_reserved;
+    Elf64_Xword ch_size;
+    Elf64_Xword ch_addralign;
 } Elf64_Chdr;
 
-#define ELFCOMPRESS_ZLIB	1
-#define ELFCOMPRESS_LOOS	0x60000000
-#define ELFCOMPRESS_HIOS	0x6fffffff
-#define ELFCOMPRESS_LOPROC	0x70000000
-#define ELFCOMPRESS_HIPROC	0x7fffffff
-
+#define ELFCOMPRESS_ZLIB 1
+#define ELFCOMPRESS_LOOS 0x60000000
+#define ELFCOMPRESS_HIOS 0x6fffffff
+#define ELFCOMPRESS_LOPROC 0x70000000
+#define ELFCOMPRESS_HIPROC 0x7fffffff
 
-#define GRP_COMDAT	0x1
+#define GRP_COMDAT 0x1
 
 typedef struct {
-  Elf32_Word	st_name;
-  Elf32_Addr	st_value;
-  Elf32_Word	st_size;
-  unsigned char	st_info;
-  unsigned char	st_other;
-  Elf32_Section	st_shndx;
+    Elf32_Word st_name;
+    Elf32_Addr st_value;
+    Elf32_Word st_size;
+    unsigned char st_info;
+    unsigned char st_other;
+    Elf32_Section st_shndx;
 } Elf32_Sym;
 
 typedef struct {
-  Elf64_Word	st_name;
-  unsigned char	st_info;
-  unsigned char st_other;
-  Elf64_Section	st_shndx;
-  Elf64_Addr	st_value;
-  Elf64_Xword	st_size;
+    Elf64_Word st_name;
+    unsigned char st_info;
+    unsigned char st_other;
+    Elf64_Section st_shndx;
+    Elf64_Addr st_value;
+    Elf64_Xword st_size;
 } Elf64_Sym;
 
 typedef struct {
-  Elf32_Half si_boundto;
-  Elf32_Half si_flags;
+    Elf32_Half si_boundto;
+    Elf32_Half si_flags;
 } Elf32_Syminfo;
 
 typedef struct {
-  Elf64_Half si_boundto;
-  Elf64_Half si_flags;
+    Elf64_Half si_boundto;
+    Elf64_Half si_flags;
 } Elf64_Syminfo;
 
-#define SYMINFO_BT_SELF		0xffff
-#define SYMINFO_BT_PARENT	0xfffe
-#define SYMINFO_BT_LOWRESERVE	0xff00
-
-#define SYMINFO_FLG_DIRECT	0x0001
-#define SYMINFO_FLG_PASSTHRU	0x0002
-#define SYMINFO_FLG_COPY	0x0004
-#define SYMINFO_FLG_LAZYLOAD	0x0008
-
-#define SYMINFO_NONE		0
-#define SYMINFO_CURRENT		1
-#define SYMINFO_NUM		2
-
-#define ELF32_ST_BIND(val)		(((unsigned char) (val)) >> 4)
-#define ELF32_ST_TYPE(val)		((val) & 0xf)
-#define ELF32_ST_INFO(bind, type)	(((bind) << 4) + ((type) & 0xf))
-
-#define ELF64_ST_BIND(val)		ELF32_ST_BIND (val)
-#define ELF64_ST_TYPE(val)		ELF32_ST_TYPE (val)
-#define ELF64_ST_INFO(bind, type)	ELF32_ST_INFO ((bind), (type))
-
-#define STB_LOCAL	0
-#define STB_GLOBAL	1
-#define STB_WEAK	2
-#define	STB_NUM		3
-#define STB_LOOS	10
-#define STB_GNU_UNIQUE	10
-#define STB_HIOS	12
-#define STB_LOPROC	13
-#define STB_HIPROC	15
-
-#define STT_NOTYPE	0
-#define STT_OBJECT	1
-#define STT_FUNC	2
-#define STT_SECTION	3
-#define STT_FILE	4
-#define STT_COMMON	5
-#define STT_TLS		6
-#define	STT_NUM		7
-#define STT_LOOS	10
-#define STT_GNU_IFUNC	10
-#define STT_HIOS	12
-#define STT_LOPROC	13
-#define STT_HIPROC	15
-
-#define STN_UNDEF	0
-
-#define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
-#define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
-
-#define STV_DEFAULT	0
-#define STV_INTERNAL	1
-#define STV_HIDDEN	2
-#define STV_PROTECTED	3
-
-
-
+#define SYMINFO_BT_SELF 0xffff
+#define SYMINFO_BT_PARENT 0xfffe
+#define SYMINFO_BT_LOWRESERVE 0xff00
+
+#define SYMINFO_FLG_DIRECT 0x0001
+#define SYMINFO_FLG_PASSTHRU 0x0002
+#define SYMINFO_FLG_COPY 0x0004
+#define SYMINFO_FLG_LAZYLOAD 0x0008
+
+#define SYMINFO_NONE 0
+#define SYMINFO_CURRENT 1
+#define SYMINFO_NUM 2
+
+#define ELF32_ST_BIND(val) (((unsigned char)(val)) >> 4)
+#define ELF32_ST_TYPE(val) ((val)&0xf)
+#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type)&0xf))
+
+#define ELF64_ST_BIND(val) ELF32_ST_BIND(val)
+#define ELF64_ST_TYPE(val) ELF32_ST_TYPE(val)
+#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO((bind), (type))
+
+#define STB_LOCAL 0
+#define STB_GLOBAL 1
+#define STB_WEAK 2
+#define STB_NUM 3
+#define STB_LOOS 10
+#define STB_GNU_UNIQUE 10
+#define STB_HIOS 12
+#define STB_LOPROC 13
+#define STB_HIPROC 15
+
+#define STT_NOTYPE 0
+#define STT_OBJECT 1
+#define STT_FUNC 2
+#define STT_SECTION 3
+#define STT_FILE 4
+#define STT_COMMON 5
+#define STT_TLS 6
+#define STT_NUM 7
+#define STT_LOOS 10
+#define STT_GNU_IFUNC 10
+#define STT_HIOS 12
+#define STT_LOPROC 13
+#define STT_HIPROC 15
+
+#define STN_UNDEF 0
+
+#define ELF32_ST_VISIBILITY(o) ((o)&0x03)
+#define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY(o)
+
+#define STV_DEFAULT 0
+#define STV_INTERNAL 1
+#define STV_HIDDEN 2
+#define STV_PROTECTED 3
 
 typedef struct {
-  Elf32_Addr	r_offset;
-  Elf32_Word	r_info;
+    Elf32_Addr r_offset;
+    Elf32_Word r_info;
 } Elf32_Rel;
 
 typedef struct {
-  Elf64_Addr	r_offset;
-  Elf64_Xword	r_info;
+    Elf64_Addr r_offset;
+    Elf64_Xword r_info;
 } Elf64_Rel;
 
-
-
 typedef struct {
-  Elf32_Addr	r_offset;
-  Elf32_Word	r_info;
-  Elf32_Sword	r_addend;
+    Elf32_Addr r_offset;
+    Elf32_Word r_info;
+    Elf32_Sword r_addend;
 } Elf32_Rela;
 
 typedef struct {
-  Elf64_Addr	r_offset;
-  Elf64_Xword	r_info;
-  Elf64_Sxword	r_addend;
+    Elf64_Addr r_offset;
+    Elf64_Xword r_info;
+    Elf64_Sxword r_addend;
 } Elf64_Rela;
 
+#define ELF32_R_SYM(val) ((val) >> 8)
+#define ELF32_R_TYPE(val) ((val)&0xff)
+#define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type)&0xff))
 
-
-#define ELF32_R_SYM(val)		((val) >> 8)
-#define ELF32_R_TYPE(val)		((val) & 0xff)
-#define ELF32_R_INFO(sym, type)		(((sym) << 8) + ((type) & 0xff))
-
-#define ELF64_R_SYM(i)			((i) >> 32)
-#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
-#define ELF64_R_INFO(sym,type)		((((Elf64_Xword) (sym)) << 32) + (type))
-
-
+#define ELF64_R_SYM(i) ((i) >> 32)
+#define ELF64_R_TYPE(i) ((i)&0xffffffff)
+#define ELF64_R_INFO(sym, type) ((((Elf64_Xword)(sym)) << 32) + (type))
 
 typedef struct {
-  Elf32_Word	p_type;
-  Elf32_Off	p_offset;
-  Elf32_Addr	p_vaddr;
-  Elf32_Addr	p_paddr;
-  Elf32_Word	p_filesz;
-  Elf32_Word	p_memsz;
-  Elf32_Word	p_flags;
-  Elf32_Word	p_align;
+    Elf32_Word p_type;
+    Elf32_Off p_offset;
+    Elf32_Addr p_vaddr;
+    Elf32_Addr p_paddr;
+    Elf32_Word p_filesz;
+    Elf32_Word p_memsz;
+    Elf32_Word p_flags;
+    Elf32_Word p_align;
 } Elf32_Phdr;
 
 typedef struct {
-  Elf64_Word	p_type;
-  Elf64_Word	p_flags;
-  Elf64_Off	p_offset;
-  Elf64_Addr	p_vaddr;
-  Elf64_Addr	p_paddr;
-  Elf64_Xword	p_filesz;
-  Elf64_Xword	p_memsz;
-  Elf64_Xword	p_align;
+    Elf64_Word p_type;
+    Elf64_Word p_flags;
+    Elf64_Off p_offset;
+    Elf64_Addr p_vaddr;
+    Elf64_Addr p_paddr;
+    Elf64_Xword p_filesz;
+    Elf64_Xword p_memsz;
+    Elf64_Xword p_align;
 } Elf64_Phdr;
 
-
-
-#define	PT_NULL		0
-#define PT_LOAD		1
-#define PT_DYNAMIC	2
-#define PT_INTERP	3
-#define PT_NOTE		4
-#define PT_SHLIB	5
-#define PT_PHDR		6
-#define PT_TLS		7
-#define	PT_NUM		8
-#define PT_LOOS		0x60000000
-#define PT_GNU_EH_FRAME	0x6474e550
-#define PT_GNU_STACK	0x6474e551
-#define PT_GNU_RELRO	0x6474e552
-#define PT_LOSUNW	0x6ffffffa
-#define PT_SUNWBSS	0x6ffffffa
-#define PT_SUNWSTACK	0x6ffffffb
-#define PT_HISUNW	0x6fffffff
-#define PT_HIOS		0x6fffffff
-#define PT_LOPROC	0x70000000
-#define PT_HIPROC	0x7fffffff
-
+#define PT_NULL 0
+#define PT_LOAD 1
+#define PT_DYNAMIC 2
+#define PT_INTERP 3
+#define PT_NOTE 4
+#define PT_SHLIB 5
+#define PT_PHDR 6
+#define PT_TLS 7
+#define PT_NUM 8
+#define PT_LOOS 0x60000000
+#define PT_GNU_EH_FRAME 0x6474e550
+#define PT_GNU_STACK 0x6474e551
+#define PT_GNU_RELRO 0x6474e552
+#define PT_LOSUNW 0x6ffffffa
+#define PT_SUNWBSS 0x6ffffffa
+#define PT_SUNWSTACK 0x6ffffffb
+#define PT_HISUNW 0x6fffffff
+#define PT_HIOS 0x6fffffff
+#define PT_LOPROC 0x70000000
+#define PT_HIPROC 0x7fffffff
 
 #define PN_XNUM 0xffff
 
-
-#define PF_X		(1 << 0)
-#define PF_W		(1 << 1)
-#define PF_R		(1 << 2)
-#define PF_MASKOS	0x0ff00000
-#define PF_MASKPROC	0xf0000000
-
-
-
-#define NT_PRSTATUS	1
-#define NT_FPREGSET	2
-#define NT_PRPSINFO	3
-#define NT_PRXREG	4
-#define NT_TASKSTRUCT	4
-#define NT_PLATFORM	5
-#define NT_AUXV		6
-#define NT_GWINDOWS	7
-#define NT_ASRS		8
-#define NT_PSTATUS	10
-#define NT_PSINFO	13
-#define NT_PRCRED	14
-#define NT_UTSNAME	15
-#define NT_LWPSTATUS	16
-#define NT_LWPSINFO	17
-#define NT_PRFPXREG	20
-#define NT_SIGINFO	0x53494749
-#define NT_FILE		0x46494c45
-#define NT_PRXFPREG	0x46e62b7f
-#define NT_PPC_VMX	0x100
-#define NT_PPC_SPE	0x101
-#define NT_PPC_VSX	0x102
-#define NT_386_TLS	0x200
-#define NT_386_IOPERM	0x201
-#define NT_X86_XSTATE	0x202
-#define NT_S390_HIGH_GPRS	0x300
-#define NT_S390_TIMER	0x301
-#define NT_S390_TODCMP	0x302
-#define NT_S390_TODPREG	0x303
-#define NT_S390_CTRS	0x304
-#define NT_S390_PREFIX	0x305
-#define NT_S390_LAST_BREAK	0x306
-#define NT_S390_SYSTEM_CALL	0x307
-#define NT_S390_TDB	0x308
-#define NT_ARM_VFP	0x400
-#define NT_ARM_TLS	0x401
-#define NT_ARM_HW_BREAK	0x402
-#define NT_ARM_HW_WATCH	0x403
-#define NT_ARM_SYSTEM_CALL	0x404
-#define NT_ARM_SVE	0x405
-#define NT_METAG_CBUF	0x500
-#define NT_METAG_RPIPE	0x501
-#define NT_METAG_TLS	0x502
-#define NT_VERSION	1
-
-
-
+#define PF_X (1 << 0)
+#define PF_W (1 << 1)
+#define PF_R (1 << 2)
+#define PF_MASKOS 0x0ff00000
+#define PF_MASKPROC 0xf0000000
+
+#define NT_PRSTATUS 1
+#define NT_FPREGSET 2
+#define NT_PRPSINFO 3
+#define NT_PRXREG 4
+#define NT_TASKSTRUCT 4
+#define NT_PLATFORM 5
+#define NT_AUXV 6
+#define NT_GWINDOWS 7
+#define NT_ASRS 8
+#define NT_PSTATUS 10
+#define NT_PSINFO 13
+#define NT_PRCRED 14
+#define NT_UTSNAME 15
+#define NT_LWPSTATUS 16
+#define NT_LWPSINFO 17
+#define NT_PRFPXREG 20
+#define NT_SIGINFO 0x53494749
+#define NT_FILE 0x46494c45
+#define NT_PRXFPREG 0x46e62b7f
+#define NT_PPC_VMX 0x100
+#define NT_PPC_SPE 0x101
+#define NT_PPC_VSX 0x102
+#define NT_386_TLS 0x200
+#define NT_386_IOPERM 0x201
+#define NT_X86_XSTATE 0x202
+#define NT_S390_HIGH_GPRS 0x300
+#define NT_S390_TIMER 0x301
+#define NT_S390_TODCMP 0x302
+#define NT_S390_TODPREG 0x303
+#define NT_S390_CTRS 0x304
+#define NT_S390_PREFIX 0x305
+#define NT_S390_LAST_BREAK 0x306
+#define NT_S390_SYSTEM_CALL 0x307
+#define NT_S390_TDB 0x308
+#define NT_ARM_VFP 0x400
+#define NT_ARM_TLS 0x401
+#define NT_ARM_HW_BREAK 0x402
+#define NT_ARM_HW_WATCH 0x403
+#define NT_ARM_SYSTEM_CALL 0x404
+#define NT_ARM_SVE 0x405
+#define NT_METAG_CBUF 0x500
+#define NT_METAG_RPIPE 0x501
+#define NT_METAG_TLS 0x502
+#define NT_VERSION 1
 
 typedef struct {
-  Elf32_Sword d_tag;
-  union {
-      Elf32_Word d_val;
-      Elf32_Addr d_ptr;
-  } d_un;
+    Elf32_Sword d_tag;
+    union {
+        Elf32_Word d_val;
+        Elf32_Addr d_ptr;
+    } d_un;
 } Elf32_Dyn;
 
 typedef struct {
-  Elf64_Sxword d_tag;
-  union {
-      Elf64_Xword d_val;
-      Elf64_Addr d_ptr;
-  } d_un;
+    Elf64_Sxword d_tag;
+    union {
+        Elf64_Xword d_val;
+        Elf64_Addr d_ptr;
+    } d_un;
 } Elf64_Dyn;
 
-
-
-#define DT_NULL		0
-#define DT_NEEDED	1
-#define DT_PLTRELSZ	2
-#define DT_PLTGOT	3
-#define DT_HASH		4
-#define DT_STRTAB	5
-#define DT_SYMTAB	6
-#define DT_RELA		7
-#define DT_RELASZ	8
-#define DT_RELAENT	9
-#define DT_STRSZ	10
-#define DT_SYMENT	11
-#define DT_INIT		12
-#define DT_FINI		13
-#define DT_SONAME	14
-#define DT_RPATH	15
-#define DT_SYMBOLIC	16
-#define DT_REL		17
-#define DT_RELSZ	18
-#define DT_RELENT	19
-#define DT_PLTREL	20
-#define DT_DEBUG	21
-#define DT_TEXTREL	22
-#define DT_JMPREL	23
-#define	DT_BIND_NOW	24
-#define	DT_INIT_ARRAY	25
-#define	DT_FINI_ARRAY	26
-#define	DT_INIT_ARRAYSZ	27
-#define	DT_FINI_ARRAYSZ	28
-#define DT_RUNPATH	29
-#define DT_FLAGS	30
-#define DT_ENCODING	32
+#define DT_NULL 0
+#define DT_NEEDED 1
+#define DT_PLTRELSZ 2
+#define DT_PLTGOT 3
+#define DT_HASH 4
+#define DT_STRTAB 5
+#define DT_SYMTAB 6
+#define DT_RELA 7
+#define DT_RELASZ 8
+#define DT_RELAENT 9
+#define DT_STRSZ 10
+#define DT_SYMENT 11
+#define DT_INIT 12
+#define DT_FINI 13
+#define DT_SONAME 14
+#define DT_RPATH 15
+#define DT_SYMBOLIC 16
+#define DT_REL 17
+#define DT_RELSZ 18
+#define DT_RELENT 19
+#define DT_PLTREL 20
+#define DT_DEBUG 21
+#define DT_TEXTREL 22
+#define DT_JMPREL 23
+#define DT_BIND_NOW 24
+#define DT_INIT_ARRAY 25
+#define DT_FINI_ARRAY 26
+#define DT_INIT_ARRAYSZ 27
+#define DT_FINI_ARRAYSZ 28
+#define DT_RUNPATH 29
+#define DT_FLAGS 30
+#define DT_ENCODING 32
 #define DT_PREINIT_ARRAY 32
 #define DT_PREINIT_ARRAYSZ 33
-#define	DT_NUM		34
-#define DT_LOOS		0x6000000d
-#define DT_HIOS		0x6ffff000
-#define DT_LOPROC	0x70000000
-#define DT_HIPROC	0x7fffffff
-#define	DT_PROCNUM	DT_MIPS_NUM
-
-#define DT_VALRNGLO	0x6ffffd00
+#define DT_NUM 34
+#define DT_LOOS 0x6000000d
+#define DT_HIOS 0x6ffff000
+#define DT_LOPROC 0x70000000
+#define DT_HIPROC 0x7fffffff
+#define DT_PROCNUM DT_MIPS_NUM
+
+#define DT_VALRNGLO 0x6ffffd00
 #define DT_GNU_PRELINKED 0x6ffffdf5
 #define DT_GNU_CONFLICTSZ 0x6ffffdf6
 #define DT_GNU_LIBLISTSZ 0x6ffffdf7
-#define DT_CHECKSUM	0x6ffffdf8
-#define DT_PLTPADSZ	0x6ffffdf9
-#define DT_MOVEENT	0x6ffffdfa
-#define DT_MOVESZ	0x6ffffdfb
-#define DT_FEATURE_1	0x6ffffdfc
-#define DT_POSFLAG_1	0x6ffffdfd
-
-#define DT_SYMINSZ	0x6ffffdfe
-#define DT_SYMINENT	0x6ffffdff
-#define DT_VALRNGHI	0x6ffffdff
-#define DT_VALTAGIDX(tag)	(DT_VALRNGHI - (tag))
+#define DT_CHECKSUM 0x6ffffdf8
+#define DT_PLTPADSZ 0x6ffffdf9
+#define DT_MOVEENT 0x6ffffdfa
+#define DT_MOVESZ 0x6ffffdfb
+#define DT_FEATURE_1 0x6ffffdfc
+#define DT_POSFLAG_1 0x6ffffdfd
+
+#define DT_SYMINSZ 0x6ffffdfe
+#define DT_SYMINENT 0x6ffffdff
+#define DT_VALRNGHI 0x6ffffdff
+#define DT_VALTAGIDX(tag) (DT_VALRNGHI - (tag))
 #define DT_VALNUM 12
 
-#define DT_ADDRRNGLO	0x6ffffe00
-#define DT_GNU_HASH	0x6ffffef5
-#define DT_TLSDESC_PLT	0x6ffffef6
-#define DT_TLSDESC_GOT	0x6ffffef7
-#define DT_GNU_CONFLICT	0x6ffffef8
-#define DT_GNU_LIBLIST	0x6ffffef9
-#define DT_CONFIG	0x6ffffefa
-#define DT_DEPAUDIT	0x6ffffefb
-#define DT_AUDIT	0x6ffffefc
-#define	DT_PLTPAD	0x6ffffefd
-#define	DT_MOVETAB	0x6ffffefe
-#define DT_SYMINFO	0x6ffffeff
-#define DT_ADDRRNGHI	0x6ffffeff
-#define DT_ADDRTAGIDX(tag)	(DT_ADDRRNGHI - (tag))
+#define DT_ADDRRNGLO 0x6ffffe00
+#define DT_GNU_HASH 0x6ffffef5
+#define DT_TLSDESC_PLT 0x6ffffef6
+#define DT_TLSDESC_GOT 0x6ffffef7
+#define DT_GNU_CONFLICT 0x6ffffef8
+#define DT_GNU_LIBLIST 0x6ffffef9
+#define DT_CONFIG 0x6ffffefa
+#define DT_DEPAUDIT 0x6ffffefb
+#define DT_AUDIT 0x6ffffefc
+#define DT_PLTPAD 0x6ffffefd
+#define DT_MOVETAB 0x6ffffefe
+#define DT_SYMINFO 0x6ffffeff
+#define DT_ADDRRNGHI 0x6ffffeff
+#define DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag))
 #define DT_ADDRNUM 11
 
+#define DT_VERSYM 0x6ffffff0
 
+#define DT_RELACOUNT 0x6ffffff9
+#define DT_RELCOUNT 0x6ffffffa
 
-#define DT_VERSYM	0x6ffffff0
-
-#define DT_RELACOUNT	0x6ffffff9
-#define DT_RELCOUNT	0x6ffffffa
+#define DT_FLAGS_1 0x6ffffffb
+#define DT_VERDEF 0x6ffffffc
 
+#define DT_VERDEFNUM 0x6ffffffd
+#define DT_VERNEED 0x6ffffffe
 
-#define DT_FLAGS_1	0x6ffffffb
-#define	DT_VERDEF	0x6ffffffc
-
-#define	DT_VERDEFNUM	0x6ffffffd
-#define	DT_VERNEED	0x6ffffffe
-
-#define	DT_VERNEEDNUM	0x6fffffff
-#define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))
+#define DT_VERNEEDNUM 0x6fffffff
+#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag))
 #define DT_VERSIONTAGNUM 16
 
-
-
-#define DT_AUXILIARY    0x7ffffffd
-#define DT_FILTER       0x7fffffff
-#define DT_EXTRATAGIDX(tag)	((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
-#define DT_EXTRANUM	3
-
-
-#define DF_ORIGIN	0x00000001
-#define DF_SYMBOLIC	0x00000002
-#define DF_TEXTREL	0x00000004
-#define DF_BIND_NOW	0x00000008
-#define DF_STATIC_TLS	0x00000010
-
-
-
-#define DF_1_NOW	0x00000001
-#define DF_1_GLOBAL	0x00000002
-#define DF_1_GROUP	0x00000004
-#define DF_1_NODELETE	0x00000008
-#define DF_1_LOADFLTR	0x00000010
-#define DF_1_INITFIRST	0x00000020
-#define DF_1_NOOPEN	0x00000040
-#define DF_1_ORIGIN	0x00000080
-#define DF_1_DIRECT	0x00000100
-#define DF_1_TRANS	0x00000200
-#define DF_1_INTERPOSE	0x00000400
-#define DF_1_NODEFLIB	0x00000800
-#define DF_1_NODUMP	0x00001000
-#define DF_1_CONFALT	0x00002000
-#define DF_1_ENDFILTEE	0x00004000
-#define	DF_1_DISPRELDNE	0x00008000
-#define	DF_1_DISPRELPND	0x00010000
-#define	DF_1_NODIRECT	0x00020000
-#define	DF_1_IGNMULDEF	0x00040000
-#define	DF_1_NOKSYMS	0x00080000
-#define	DF_1_NOHDR	0x00100000
-#define	DF_1_EDITED	0x00200000
-#define	DF_1_NORELOC	0x00400000
-#define	DF_1_SYMINTPOSE	0x00800000
-#define	DF_1_GLOBAUDIT	0x01000000
-#define	DF_1_SINGLETON	0x02000000
-
-#define DTF_1_PARINIT	0x00000001
-#define DTF_1_CONFEXP	0x00000002
-
-
-#define DF_P1_LAZYLOAD	0x00000001
-#define DF_P1_GROUPPERM	0x00000002
-
-
-
+#define DT_AUXILIARY 0x7ffffffd
+#define DT_FILTER 0x7fffffff
+#define DT_EXTRATAGIDX(tag) ((Elf32_Word) - ((Elf32_Sword)(tag) << 1 >> 1) - 1)
+#define DT_EXTRANUM 3
+
+#define DF_ORIGIN 0x00000001
+#define DF_SYMBOLIC 0x00000002
+#define DF_TEXTREL 0x00000004
+#define DF_BIND_NOW 0x00000008
+#define DF_STATIC_TLS 0x00000010
+
+#define DF_1_NOW 0x00000001
+#define DF_1_GLOBAL 0x00000002
+#define DF_1_GROUP 0x00000004
+#define DF_1_NODELETE 0x00000008
+#define DF_1_LOADFLTR 0x00000010
+#define DF_1_INITFIRST 0x00000020
+#define DF_1_NOOPEN 0x00000040
+#define DF_1_ORIGIN 0x00000080
+#define DF_1_DIRECT 0x00000100
+#define DF_1_TRANS 0x00000200
+#define DF_1_INTERPOSE 0x00000400
+#define DF_1_NODEFLIB 0x00000800
+#define DF_1_NODUMP 0x00001000
+#define DF_1_CONFALT 0x00002000
+#define DF_1_ENDFILTEE 0x00004000
+#define DF_1_DISPRELDNE 0x00008000
+#define DF_1_DISPRELPND 0x00010000
+#define DF_1_NODIRECT 0x00020000
+#define DF_1_IGNMULDEF 0x00040000
+#define DF_1_NOKSYMS 0x00080000
+#define DF_1_NOHDR 0x00100000
+#define DF_1_EDITED 0x00200000
+#define DF_1_NORELOC 0x00400000
+#define DF_1_SYMINTPOSE 0x00800000
+#define DF_1_GLOBAUDIT 0x01000000
+#define DF_1_SINGLETON 0x02000000
+
+#define DTF_1_PARINIT 0x00000001
+#define DTF_1_CONFEXP 0x00000002
+
+#define DF_P1_LAZYLOAD 0x00000001
+#define DF_P1_GROUPPERM 0x00000002
 
 typedef struct {
-  Elf32_Half	vd_version;
-  Elf32_Half	vd_flags;
-  Elf32_Half	vd_ndx;
-  Elf32_Half	vd_cnt;
-  Elf32_Word	vd_hash;
-  Elf32_Word	vd_aux;
-  Elf32_Word	vd_next;
+    Elf32_Half vd_version;
+    Elf32_Half vd_flags;
+    Elf32_Half vd_ndx;
+    Elf32_Half vd_cnt;
+    Elf32_Word vd_hash;
+    Elf32_Word vd_aux;
+    Elf32_Word vd_next;
 } Elf32_Verdef;
 
 typedef struct {
-  Elf64_Half	vd_version;
-  Elf64_Half	vd_flags;
-  Elf64_Half	vd_ndx;
-  Elf64_Half	vd_cnt;
-  Elf64_Word	vd_hash;
-  Elf64_Word	vd_aux;
-  Elf64_Word	vd_next;
+    Elf64_Half vd_version;
+    Elf64_Half vd_flags;
+    Elf64_Half vd_ndx;
+    Elf64_Half vd_cnt;
+    Elf64_Word vd_hash;
+    Elf64_Word vd_aux;
+    Elf64_Word vd_next;
 } Elf64_Verdef;
 
+#define VER_DEF_NONE 0
+#define VER_DEF_CURRENT 1
+#define VER_DEF_NUM 2
 
+#define VER_FLG_BASE 0x1
+#define VER_FLG_WEAK 0x2
 
-#define VER_DEF_NONE	0
-#define VER_DEF_CURRENT	1
-#define VER_DEF_NUM	2
-
-
-#define VER_FLG_BASE	0x1
-#define VER_FLG_WEAK	0x2
-
-
-#define	VER_NDX_LOCAL		0
-#define	VER_NDX_GLOBAL		1
-#define	VER_NDX_LORESERVE	0xff00
-#define	VER_NDX_ELIMINATE	0xff01
-
-
+#define VER_NDX_LOCAL 0
+#define VER_NDX_GLOBAL 1
+#define VER_NDX_LORESERVE 0xff00
+#define VER_NDX_ELIMINATE 0xff01
 
 typedef struct {
-  Elf32_Word	vda_name;
-  Elf32_Word	vda_next;
+    Elf32_Word vda_name;
+    Elf32_Word vda_next;
 } Elf32_Verdaux;
 
 typedef struct {
-  Elf64_Word	vda_name;
-  Elf64_Word	vda_next;
+    Elf64_Word vda_name;
+    Elf64_Word vda_next;
 } Elf64_Verdaux;
 
-
-
-
 typedef struct {
-  Elf32_Half	vn_version;
-  Elf32_Half	vn_cnt;
-  Elf32_Word	vn_file;
-  Elf32_Word	vn_aux;
-  Elf32_Word	vn_next;
+    Elf32_Half vn_version;
+    Elf32_Half vn_cnt;
+    Elf32_Word vn_file;
+    Elf32_Word vn_aux;
+    Elf32_Word vn_next;
 } Elf32_Verneed;
 
 typedef struct {
-  Elf64_Half	vn_version;
-  Elf64_Half	vn_cnt;
-  Elf64_Word	vn_file;
-  Elf64_Word	vn_aux;
-  Elf64_Word	vn_next;
+    Elf64_Half vn_version;
+    Elf64_Half vn_cnt;
+    Elf64_Word vn_file;
+    Elf64_Word vn_aux;
+    Elf64_Word vn_next;
 } Elf64_Verneed;
 
-
-
-#define VER_NEED_NONE	 0
+#define VER_NEED_NONE 0
 #define VER_NEED_CURRENT 1
-#define VER_NEED_NUM	 2
-
-
+#define VER_NEED_NUM 2
 
 typedef struct {
-  Elf32_Word	vna_hash;
-  Elf32_Half	vna_flags;
-  Elf32_Half	vna_other;
-  Elf32_Word	vna_name;
-  Elf32_Word	vna_next;
+    Elf32_Word vna_hash;
+    Elf32_Half vna_flags;
+    Elf32_Half vna_other;
+    Elf32_Word vna_name;
+    Elf32_Word vna_next;
 } Elf32_Vernaux;
 
 typedef struct {
-  Elf64_Word	vna_hash;
-  Elf64_Half	vna_flags;
-  Elf64_Half	vna_other;
-  Elf64_Word	vna_name;
-  Elf64_Word	vna_next;
+    Elf64_Word vna_hash;
+    Elf64_Half vna_flags;
+    Elf64_Half vna_other;
+    Elf64_Word vna_name;
+    Elf64_Word vna_next;
 } Elf64_Vernaux;
 
-
-
-#define VER_FLG_WEAK	0x2
-
-
+#define VER_FLG_WEAK 0x2
 
 typedef struct {
-  uint32_t a_type;
-  union {
-      uint32_t a_val;
-  } a_un;
+    uint32_t a_type;
+    union {
+        uint32_t a_val;
+    } a_un;
 } Elf32_auxv_t;
 
 typedef struct {
-  uint64_t a_type;
-  union {
-      uint64_t a_val;
-  } a_un;
+    uint64_t a_type;
+    union {
+        uint64_t a_val;
+    } a_un;
 } Elf64_auxv_t;
 
+#define AT_NULL 0
+#define AT_IGNORE 1
+#define AT_EXECFD 2
+#define AT_PHDR 3
+#define AT_PHENT 4
+#define AT_PHNUM 5
+#define AT_PAGESZ 6
+#define AT_BASE 7
+#define AT_FLAGS 8
+#define AT_ENTRY 9
+#define AT_NOTELF 10
+#define AT_UID 11
+#define AT_EUID 12
+#define AT_GID 13
+#define AT_EGID 14
+#define AT_CLKTCK 17
 
+#define AT_PLATFORM 15
+#define AT_HWCAP 16
 
-#define AT_NULL		0
-#define AT_IGNORE	1
-#define AT_EXECFD	2
-#define AT_PHDR		3
-#define AT_PHENT	4
-#define AT_PHNUM	5
-#define AT_PAGESZ	6
-#define AT_BASE		7
-#define AT_FLAGS	8
-#define AT_ENTRY	9
-#define AT_NOTELF	10
-#define AT_UID		11
-#define AT_EUID		12
-#define AT_GID		13
-#define AT_EGID		14
-#define AT_CLKTCK	17
-
-
-#define AT_PLATFORM	15
-#define AT_HWCAP	16
+#define AT_FPUCW 18
 
+#define AT_DCACHEBSIZE 19
+#define AT_ICACHEBSIZE 20
+#define AT_UCACHEBSIZE 21
 
+#define AT_IGNOREPPC 22
 
-
-#define AT_FPUCW	18
-
-
-#define AT_DCACHEBSIZE	19
-#define AT_ICACHEBSIZE	20
-#define AT_UCACHEBSIZE	21
-
-
-
-#define AT_IGNOREPPC	22
-
-#define	AT_SECURE	23
+#define AT_SECURE 23
 
 #define AT_BASE_PLATFORM 24
 
-#define AT_RANDOM	25
-
-#define AT_HWCAP2	26
-
-#define AT_EXECFN	31
-
-
-
-#define AT_SYSINFO	32
-#define AT_SYSINFO_EHDR	33
+#define AT_RANDOM 25
 
+#define AT_HWCAP2 26
 
+#define AT_EXECFN 31
 
-#define AT_L1I_CACHESHAPE	34
-#define AT_L1D_CACHESHAPE	35
-#define AT_L2_CACHESHAPE	36
-#define AT_L3_CACHESHAPE	37
-
-
+#define AT_SYSINFO 32
+#define AT_SYSINFO_EHDR 33
 
+#define AT_L1I_CACHESHAPE 34
+#define AT_L1D_CACHESHAPE 35
+#define AT_L2_CACHESHAPE 36
+#define AT_L3_CACHESHAPE 37
 
 typedef struct {
-  Elf32_Word n_namesz;
-  Elf32_Word n_descsz;
-  Elf32_Word n_type;
+    Elf32_Word n_namesz;
+    Elf32_Word n_descsz;
+    Elf32_Word n_type;
 } Elf32_Nhdr;
 
 typedef struct {
-  Elf64_Word n_namesz;
-  Elf64_Word n_descsz;
-  Elf64_Word n_type;
+    Elf64_Word n_namesz;
+    Elf64_Word n_descsz;
+    Elf64_Word n_type;
 } Elf64_Nhdr;
 
+#define ELF_NOTE_SOLARIS "SUNW Solaris"
 
+#define ELF_NOTE_GNU "GNU"
 
+#define ELF_NOTE_PAGESIZE_HINT 1
 
-#define ELF_NOTE_SOLARIS	"SUNW Solaris"
-
-
-#define ELF_NOTE_GNU		"GNU"
-
-
-
-
-
-#define ELF_NOTE_PAGESIZE_HINT	1
-
-
-#define NT_GNU_ABI_TAG	1
-#define ELF_NOTE_ABI	NT_GNU_ABI_TAG
-
-
-
-#define ELF_NOTE_OS_LINUX	0
-#define ELF_NOTE_OS_GNU		1
-#define ELF_NOTE_OS_SOLARIS2	2
-#define ELF_NOTE_OS_FREEBSD	3
-
-#define NT_GNU_BUILD_ID	3
-#define NT_GNU_GOLD_VERSION	4
+#define NT_GNU_ABI_TAG 1
+#define ELF_NOTE_ABI NT_GNU_ABI_TAG
 
+#define ELF_NOTE_OS_LINUX 0
+#define ELF_NOTE_OS_GNU 1
+#define ELF_NOTE_OS_SOLARIS2 2
+#define ELF_NOTE_OS_FREEBSD 3
 
+#define NT_GNU_BUILD_ID 3
+#define NT_GNU_GOLD_VERSION 4
 
 typedef struct {
-  Elf32_Xword m_value;
-  Elf32_Word m_info;
-  Elf32_Word m_poffset;
-  Elf32_Half m_repeat;
-  Elf32_Half m_stride;
+    Elf32_Xword m_value;
+    Elf32_Word m_info;
+    Elf32_Word m_poffset;
+    Elf32_Half m_repeat;
+    Elf32_Half m_stride;
 } Elf32_Move;
 
 typedef struct {
-  Elf64_Xword m_value;
-  Elf64_Xword m_info;
-  Elf64_Xword m_poffset;
-  Elf64_Half m_repeat;
-  Elf64_Half m_stride;
+    Elf64_Xword m_value;
+    Elf64_Xword m_info;
+    Elf64_Xword m_poffset;
+    Elf64_Half m_repeat;
+    Elf64_Half m_stride;
 } Elf64_Move;
 
-
-#define ELF32_M_SYM(info)	((info) >> 8)
-#define ELF32_M_SIZE(info)	((unsigned char) (info))
-#define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))
-
-#define ELF64_M_SYM(info)	ELF32_M_SYM (info)
-#define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
-#define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)
-
-#define EF_CPU32	0x00810000
-
-#define R_68K_NONE	0
-#define R_68K_32	1
-#define R_68K_16	2
-#define R_68K_8		3
-#define R_68K_PC32	4
-#define R_68K_PC16	5
-#define R_68K_PC8	6
-#define R_68K_GOT32	7
-#define R_68K_GOT16	8
-#define R_68K_GOT8	9
-#define R_68K_GOT32O	10
-#define R_68K_GOT16O	11
-#define R_68K_GOT8O	12
-#define R_68K_PLT32	13
-#define R_68K_PLT16	14
-#define R_68K_PLT8	15
-#define R_68K_PLT32O	16
-#define R_68K_PLT16O	17
-#define R_68K_PLT8O	18
-#define R_68K_COPY	19
-#define R_68K_GLOB_DAT	20
-#define R_68K_JMP_SLOT	21
-#define R_68K_RELATIVE	22
-#define R_68K_NUM	23
-
-#define R_386_NONE	   0
-#define R_386_32	   1
-#define R_386_PC32	   2
-#define R_386_GOT32	   3
-#define R_386_PLT32	   4
-#define R_386_COPY	   5
-#define R_386_GLOB_DAT	   6
-#define R_386_JMP_SLOT	   7
-#define R_386_RELATIVE	   8
-#define R_386_GOTOFF	   9
-#define R_386_GOTPC	   10
-#define R_386_32PLT	   11
-#define R_386_TLS_TPOFF	   14
-#define R_386_TLS_IE	   15
-#define R_386_TLS_GOTIE	   16
-#define R_386_TLS_LE	   17
-#define R_386_TLS_GD	   18
-#define R_386_TLS_LDM	   19
-#define R_386_16	   20
-#define R_386_PC16	   21
-#define R_386_8		   22
-#define R_386_PC8	   23
-#define R_386_TLS_GD_32	   24
-#define R_386_TLS_GD_PUSH  25
-#define R_386_TLS_GD_CALL  26
-#define R_386_TLS_GD_POP   27
-#define R_386_TLS_LDM_32   28
+#define ELF32_M_SYM(info) ((info) >> 8)
+#define ELF32_M_SIZE(info) ((unsigned char)(info))
+#define ELF32_M_INFO(sym, size) (((sym) << 8) + (unsigned char)(size))
+
+#define ELF64_M_SYM(info) ELF32_M_SYM(info)
+#define ELF64_M_SIZE(info) ELF32_M_SIZE(info)
+#define ELF64_M_INFO(sym, size) ELF32_M_INFO(sym, size)
+
+#define EF_CPU32 0x00810000
+
+#define R_68K_NONE 0
+#define R_68K_32 1
+#define R_68K_16 2
+#define R_68K_8 3
+#define R_68K_PC32 4
+#define R_68K_PC16 5
+#define R_68K_PC8 6
+#define R_68K_GOT32 7
+#define R_68K_GOT16 8
+#define R_68K_GOT8 9
+#define R_68K_GOT32O 10
+#define R_68K_GOT16O 11
+#define R_68K_GOT8O 12
+#define R_68K_PLT32 13
+#define R_68K_PLT16 14
+#define R_68K_PLT8 15
+#define R_68K_PLT32O 16
+#define R_68K_PLT16O 17
+#define R_68K_PLT8O 18
+#define R_68K_COPY 19
+#define R_68K_GLOB_DAT 20
+#define R_68K_JMP_SLOT 21
+#define R_68K_RELATIVE 22
+#define R_68K_NUM 23
+
+#define R_386_NONE 0
+#define R_386_32 1
+#define R_386_PC32 2
+#define R_386_GOT32 3
+#define R_386_PLT32 4
+#define R_386_COPY 5
+#define R_386_GLOB_DAT 6
+#define R_386_JMP_SLOT 7
+#define R_386_RELATIVE 8
+#define R_386_GOTOFF 9
+#define R_386_GOTPC 10
+#define R_386_32PLT 11
+#define R_386_TLS_TPOFF 14
+#define R_386_TLS_IE 15
+#define R_386_TLS_GOTIE 16
+#define R_386_TLS_LE 17
+#define R_386_TLS_GD 18
+#define R_386_TLS_LDM 19
+#define R_386_16 20
+#define R_386_PC16 21
+#define R_386_8 22
+#define R_386_PC8 23
+#define R_386_TLS_GD_32 24
+#define R_386_TLS_GD_PUSH 25
+#define R_386_TLS_GD_CALL 26
+#define R_386_TLS_GD_POP 27
+#define R_386_TLS_LDM_32 28
 #define R_386_TLS_LDM_PUSH 29
 #define R_386_TLS_LDM_CALL 30
-#define R_386_TLS_LDM_POP  31
-#define R_386_TLS_LDO_32   32
-#define R_386_TLS_IE_32	   33
-#define R_386_TLS_LE_32	   34
+#define R_386_TLS_LDM_POP 31
+#define R_386_TLS_LDO_32 32
+#define R_386_TLS_IE_32 33
+#define R_386_TLS_LE_32 34
 #define R_386_TLS_DTPMOD32 35
 #define R_386_TLS_DTPOFF32 36
-#define R_386_TLS_TPOFF32  37
-#define R_386_SIZE32       38
-#define R_386_TLS_GOTDESC  39
+#define R_386_TLS_TPOFF32 37
+#define R_386_SIZE32 38
+#define R_386_TLS_GOTDESC 39
 #define R_386_TLS_DESC_CALL 40
-#define R_386_TLS_DESC     41
-#define R_386_IRELATIVE	   42
-#define R_386_GOT32X	   43
-#define R_386_NUM	   44
-
-
-
-
-
-#define STT_SPARC_REGISTER	13
-
-
-
-#define EF_SPARCV9_MM		3
-#define EF_SPARCV9_TSO		0
-#define EF_SPARCV9_PSO		1
-#define EF_SPARCV9_RMO		2
-#define EF_SPARC_LEDATA		0x800000
-#define EF_SPARC_EXT_MASK	0xFFFF00
-#define EF_SPARC_32PLUS		0x000100
-#define EF_SPARC_SUN_US1	0x000200
-#define EF_SPARC_HAL_R1		0x000400
-#define EF_SPARC_SUN_US3	0x000800
-
-
-
-#define R_SPARC_NONE		0
-#define R_SPARC_8		1
-#define R_SPARC_16		2
-#define R_SPARC_32		3
-#define R_SPARC_DISP8		4
-#define R_SPARC_DISP16		5
-#define R_SPARC_DISP32		6
-#define R_SPARC_WDISP30		7
-#define R_SPARC_WDISP22		8
-#define R_SPARC_HI22		9
-#define R_SPARC_22		10
-#define R_SPARC_13		11
-#define R_SPARC_LO10		12
-#define R_SPARC_GOT10		13
-#define R_SPARC_GOT13		14
-#define R_SPARC_GOT22		15
-#define R_SPARC_PC10		16
-#define R_SPARC_PC22		17
-#define R_SPARC_WPLT30		18
-#define R_SPARC_COPY		19
-#define R_SPARC_GLOB_DAT	20
-#define R_SPARC_JMP_SLOT	21
-#define R_SPARC_RELATIVE	22
-#define R_SPARC_UA32		23
-
-
-
-#define R_SPARC_PLT32		24
-#define R_SPARC_HIPLT22		25
-#define R_SPARC_LOPLT10		26
-#define R_SPARC_PCPLT32		27
-#define R_SPARC_PCPLT22		28
-#define R_SPARC_PCPLT10		29
-#define R_SPARC_10		30
-#define R_SPARC_11		31
-#define R_SPARC_64		32
-#define R_SPARC_OLO10		33
-#define R_SPARC_HH22		34
-#define R_SPARC_HM10		35
-#define R_SPARC_LM22		36
-#define R_SPARC_PC_HH22		37
-#define R_SPARC_PC_HM10		38
-#define R_SPARC_PC_LM22		39
-#define R_SPARC_WDISP16		40
-#define R_SPARC_WDISP19		41
-#define R_SPARC_GLOB_JMP	42
-#define R_SPARC_7		43
-#define R_SPARC_5		44
-#define R_SPARC_6		45
-#define R_SPARC_DISP64		46
-#define R_SPARC_PLT64		47
-#define R_SPARC_HIX22		48
-#define R_SPARC_LOX10		49
-#define R_SPARC_H44		50
-#define R_SPARC_M44		51
-#define R_SPARC_L44		52
-#define R_SPARC_REGISTER	53
-#define R_SPARC_UA64		54
-#define R_SPARC_UA16		55
-#define R_SPARC_TLS_GD_HI22	56
-#define R_SPARC_TLS_GD_LO10	57
-#define R_SPARC_TLS_GD_ADD	58
-#define R_SPARC_TLS_GD_CALL	59
-#define R_SPARC_TLS_LDM_HI22	60
-#define R_SPARC_TLS_LDM_LO10	61
-#define R_SPARC_TLS_LDM_ADD	62
-#define R_SPARC_TLS_LDM_CALL	63
-#define R_SPARC_TLS_LDO_HIX22	64
-#define R_SPARC_TLS_LDO_LOX10	65
-#define R_SPARC_TLS_LDO_ADD	66
-#define R_SPARC_TLS_IE_HI22	67
-#define R_SPARC_TLS_IE_LO10	68
-#define R_SPARC_TLS_IE_LD	69
-#define R_SPARC_TLS_IE_LDX	70
-#define R_SPARC_TLS_IE_ADD	71
-#define R_SPARC_TLS_LE_HIX22	72
-#define R_SPARC_TLS_LE_LOX10	73
-#define R_SPARC_TLS_DTPMOD32	74
-#define R_SPARC_TLS_DTPMOD64	75
-#define R_SPARC_TLS_DTPOFF32	76
-#define R_SPARC_TLS_DTPOFF64	77
-#define R_SPARC_TLS_TPOFF32	78
-#define R_SPARC_TLS_TPOFF64	79
-#define R_SPARC_GOTDATA_HIX22	80
-#define R_SPARC_GOTDATA_LOX10	81
-#define R_SPARC_GOTDATA_OP_HIX22	82
-#define R_SPARC_GOTDATA_OP_LOX10	83
-#define R_SPARC_GOTDATA_OP	84
-#define R_SPARC_H34		85
-#define R_SPARC_SIZE32		86
-#define R_SPARC_SIZE64		87
-#define R_SPARC_GNU_VTINHERIT	250
-#define R_SPARC_GNU_VTENTRY	251
-#define R_SPARC_REV32		252
-
-#define R_SPARC_NUM		253
-
-
+#define R_386_TLS_DESC 41
+#define R_386_IRELATIVE 42
+#define R_386_GOT32X 43
+#define R_386_NUM 44
+
+#define STT_SPARC_REGISTER 13
+
+#define EF_SPARCV9_MM 3
+#define EF_SPARCV9_TSO 0
+#define EF_SPARCV9_PSO 1
+#define EF_SPARCV9_RMO 2
+#define EF_SPARC_LEDATA 0x800000
+#define EF_SPARC_EXT_MASK 0xFFFF00
+#define EF_SPARC_32PLUS 0x000100
+#define EF_SPARC_SUN_US1 0x000200
+#define EF_SPARC_HAL_R1 0x000400
+#define EF_SPARC_SUN_US3 0x000800
+
+#define R_SPARC_NONE 0
+#define R_SPARC_8 1
+#define R_SPARC_16 2
+#define R_SPARC_32 3
+#define R_SPARC_DISP8 4
+#define R_SPARC_DISP16 5
+#define R_SPARC_DISP32 6
+#define R_SPARC_WDISP30 7
+#define R_SPARC_WDISP22 8
+#define R_SPARC_HI22 9
+#define R_SPARC_22 10
+#define R_SPARC_13 11
+#define R_SPARC_LO10 12
+#define R_SPARC_GOT10 13
+#define R_SPARC_GOT13 14
+#define R_SPARC_GOT22 15
+#define R_SPARC_PC10 16
+#define R_SPARC_PC22 17
+#define R_SPARC_WPLT30 18
+#define R_SPARC_COPY 19
+#define R_SPARC_GLOB_DAT 20
+#define R_SPARC_JMP_SLOT 21
+#define R_SPARC_RELATIVE 22
+#define R_SPARC_UA32 23
+
+#define R_SPARC_PLT32 24
+#define R_SPARC_HIPLT22 25
+#define R_SPARC_LOPLT10 26
+#define R_SPARC_PCPLT32 27
+#define R_SPARC_PCPLT22 28
+#define R_SPARC_PCPLT10 29
+#define R_SPARC_10 30
+#define R_SPARC_11 31
+#define R_SPARC_64 32
+#define R_SPARC_OLO10 33
+#define R_SPARC_HH22 34
+#define R_SPARC_HM10 35
+#define R_SPARC_LM22 36
+#define R_SPARC_PC_HH22 37
+#define R_SPARC_PC_HM10 38
+#define R_SPARC_PC_LM22 39
+#define R_SPARC_WDISP16 40
+#define R_SPARC_WDISP19 41
+#define R_SPARC_GLOB_JMP 42
+#define R_SPARC_7 43
+#define R_SPARC_5 44
+#define R_SPARC_6 45
+#define R_SPARC_DISP64 46
+#define R_SPARC_PLT64 47
+#define R_SPARC_HIX22 48
+#define R_SPARC_LOX10 49
+#define R_SPARC_H44 50
+#define R_SPARC_M44 51
+#define R_SPARC_L44 52
+#define R_SPARC_REGISTER 53
+#define R_SPARC_UA64 54
+#define R_SPARC_UA16 55
+#define R_SPARC_TLS_GD_HI22 56
+#define R_SPARC_TLS_GD_LO10 57
+#define R_SPARC_TLS_GD_ADD 58
+#define R_SPARC_TLS_GD_CALL 59
+#define R_SPARC_TLS_LDM_HI22 60
+#define R_SPARC_TLS_LDM_LO10 61
+#define R_SPARC_TLS_LDM_ADD 62
+#define R_SPARC_TLS_LDM_CALL 63
+#define R_SPARC_TLS_LDO_HIX22 64
+#define R_SPARC_TLS_LDO_LOX10 65
+#define R_SPARC_TLS_LDO_ADD 66
+#define R_SPARC_TLS_IE_HI22 67
+#define R_SPARC_TLS_IE_LO10 68
+#define R_SPARC_TLS_IE_LD 69
+#define R_SPARC_TLS_IE_LDX 70
+#define R_SPARC_TLS_IE_ADD 71
+#define R_SPARC_TLS_LE_HIX22 72
+#define R_SPARC_TLS_LE_LOX10 73
+#define R_SPARC_TLS_DTPMOD32 74
+#define R_SPARC_TLS_DTPMOD64 75
+#define R_SPARC_TLS_DTPOFF32 76
+#define R_SPARC_TLS_DTPOFF64 77
+#define R_SPARC_TLS_TPOFF32 78
+#define R_SPARC_TLS_TPOFF64 79
+#define R_SPARC_GOTDATA_HIX22 80
+#define R_SPARC_GOTDATA_LOX10 81
+#define R_SPARC_GOTDATA_OP_HIX22 82
+#define R_SPARC_GOTDATA_OP_LOX10 83
+#define R_SPARC_GOTDATA_OP 84
+#define R_SPARC_H34 85
+#define R_SPARC_SIZE32 86
+#define R_SPARC_SIZE64 87
+#define R_SPARC_GNU_VTINHERIT 250
+#define R_SPARC_GNU_VTENTRY 251
+#define R_SPARC_REV32 252
+
+#define R_SPARC_NUM 253
 
 #define DT_SPARC_REGISTER 0x70000001
-#define DT_SPARC_NUM	2
-
+#define DT_SPARC_NUM 2
 
-#define EF_MIPS_NOREORDER   1
-#define EF_MIPS_PIC	    2
-#define EF_MIPS_CPIC	    4
-#define EF_MIPS_XGOT	    8
+#define EF_MIPS_NOREORDER 1
+#define EF_MIPS_PIC 2
+#define EF_MIPS_CPIC 4
+#define EF_MIPS_XGOT 8
 #define EF_MIPS_64BIT_WHIRL 16
-#define EF_MIPS_ABI2	    32
-#define EF_MIPS_ABI_ON32    64
-#define EF_MIPS_FP64	    512
-#define EF_MIPS_NAN2008     1024
-#define EF_MIPS_ARCH	    0xf0000000
-
-
-
-#define EF_MIPS_ARCH_1	    0x00000000
-#define EF_MIPS_ARCH_2	    0x10000000
-#define EF_MIPS_ARCH_3	    0x20000000
-#define EF_MIPS_ARCH_4	    0x30000000
-#define EF_MIPS_ARCH_5	    0x40000000
-#define EF_MIPS_ARCH_32     0x50000000
-#define EF_MIPS_ARCH_64     0x60000000
-#define EF_MIPS_ARCH_32R2   0x70000000
-#define EF_MIPS_ARCH_64R2   0x80000000
-
-
-#define E_MIPS_ARCH_1	  0x00000000
-#define E_MIPS_ARCH_2	  0x10000000
-#define E_MIPS_ARCH_3	  0x20000000
-#define E_MIPS_ARCH_4	  0x30000000
-#define E_MIPS_ARCH_5	  0x40000000
-#define E_MIPS_ARCH_32	  0x50000000
-#define E_MIPS_ARCH_64	  0x60000000
-
-
-
-#define SHN_MIPS_ACOMMON    0xff00
-#define SHN_MIPS_TEXT	    0xff01
-#define SHN_MIPS_DATA	    0xff02
-#define SHN_MIPS_SCOMMON    0xff03
+#define EF_MIPS_ABI2 32
+#define EF_MIPS_ABI_ON32 64
+#define EF_MIPS_FP64 512
+#define EF_MIPS_NAN2008 1024
+#define EF_MIPS_ARCH 0xf0000000
+
+#define EF_MIPS_ARCH_1 0x00000000
+#define EF_MIPS_ARCH_2 0x10000000
+#define EF_MIPS_ARCH_3 0x20000000
+#define EF_MIPS_ARCH_4 0x30000000
+#define EF_MIPS_ARCH_5 0x40000000
+#define EF_MIPS_ARCH_32 0x50000000
+#define EF_MIPS_ARCH_64 0x60000000
+#define EF_MIPS_ARCH_32R2 0x70000000
+#define EF_MIPS_ARCH_64R2 0x80000000
+
+#define E_MIPS_ARCH_1 0x00000000
+#define E_MIPS_ARCH_2 0x10000000
+#define E_MIPS_ARCH_3 0x20000000
+#define E_MIPS_ARCH_4 0x30000000
+#define E_MIPS_ARCH_5 0x40000000
+#define E_MIPS_ARCH_32 0x50000000
+#define E_MIPS_ARCH_64 0x60000000
+
+#define SHN_MIPS_ACOMMON 0xff00
+#define SHN_MIPS_TEXT 0xff01
+#define SHN_MIPS_DATA 0xff02
+#define SHN_MIPS_SCOMMON 0xff03
 #define SHN_MIPS_SUNDEFINED 0xff04
 
-
-
-#define SHT_MIPS_LIBLIST       0x70000000
-#define SHT_MIPS_MSYM	       0x70000001
-#define SHT_MIPS_CONFLICT      0x70000002
-#define SHT_MIPS_GPTAB	       0x70000003
-#define SHT_MIPS_UCODE	       0x70000004
-#define SHT_MIPS_DEBUG	       0x70000005
-#define SHT_MIPS_REGINFO       0x70000006
-#define SHT_MIPS_PACKAGE       0x70000007
-#define SHT_MIPS_PACKSYM       0x70000008
-#define SHT_MIPS_RELD	       0x70000009
-#define SHT_MIPS_IFACE         0x7000000b
-#define SHT_MIPS_CONTENT       0x7000000c
-#define SHT_MIPS_OPTIONS       0x7000000d
-#define SHT_MIPS_SHDR	       0x70000010
-#define SHT_MIPS_FDESC	       0x70000011
-#define SHT_MIPS_EXTSYM	       0x70000012
-#define SHT_MIPS_DENSE	       0x70000013
-#define SHT_MIPS_PDESC	       0x70000014
-#define SHT_MIPS_LOCSYM	       0x70000015
-#define SHT_MIPS_AUXSYM	       0x70000016
-#define SHT_MIPS_OPTSYM	       0x70000017
-#define SHT_MIPS_LOCSTR	       0x70000018
-#define SHT_MIPS_LINE	       0x70000019
-#define SHT_MIPS_RFDESC	       0x7000001a
-#define SHT_MIPS_DELTASYM      0x7000001b
-#define SHT_MIPS_DELTAINST     0x7000001c
-#define SHT_MIPS_DELTACLASS    0x7000001d
-#define SHT_MIPS_DWARF         0x7000001e
-#define SHT_MIPS_DELTADECL     0x7000001f
-#define SHT_MIPS_SYMBOL_LIB    0x70000020
-#define SHT_MIPS_EVENTS	       0x70000021
-#define SHT_MIPS_TRANSLATE     0x70000022
-#define SHT_MIPS_PIXIE	       0x70000023
-#define SHT_MIPS_XLATE	       0x70000024
-#define SHT_MIPS_XLATE_DEBUG   0x70000025
-#define SHT_MIPS_WHIRL	       0x70000026
-#define SHT_MIPS_EH_REGION     0x70000027
-#define SHT_MIPS_XLATE_OLD     0x70000028
+#define SHT_MIPS_LIBLIST 0x70000000
+#define SHT_MIPS_MSYM 0x70000001
+#define SHT_MIPS_CONFLICT 0x70000002
+#define SHT_MIPS_GPTAB 0x70000003
+#define SHT_MIPS_UCODE 0x70000004
+#define SHT_MIPS_DEBUG 0x70000005
+#define SHT_MIPS_REGINFO 0x70000006
+#define SHT_MIPS_PACKAGE 0x70000007
+#define SHT_MIPS_PACKSYM 0x70000008
+#define SHT_MIPS_RELD 0x70000009
+#define SHT_MIPS_IFACE 0x7000000b
+#define SHT_MIPS_CONTENT 0x7000000c
+#define SHT_MIPS_OPTIONS 0x7000000d
+#define SHT_MIPS_SHDR 0x70000010
+#define SHT_MIPS_FDESC 0x70000011
+#define SHT_MIPS_EXTSYM 0x70000012
+#define SHT_MIPS_DENSE 0x70000013
+#define SHT_MIPS_PDESC 0x70000014
+#define SHT_MIPS_LOCSYM 0x70000015
+#define SHT_MIPS_AUXSYM 0x70000016
+#define SHT_MIPS_OPTSYM 0x70000017
+#define SHT_MIPS_LOCSTR 0x70000018
+#define SHT_MIPS_LINE 0x70000019
+#define SHT_MIPS_RFDESC 0x7000001a
+#define SHT_MIPS_DELTASYM 0x7000001b
+#define SHT_MIPS_DELTAINST 0x7000001c
+#define SHT_MIPS_DELTACLASS 0x7000001d
+#define SHT_MIPS_DWARF 0x7000001e
+#define SHT_MIPS_DELTADECL 0x7000001f
+#define SHT_MIPS_SYMBOL_LIB 0x70000020
+#define SHT_MIPS_EVENTS 0x70000021
+#define SHT_MIPS_TRANSLATE 0x70000022
+#define SHT_MIPS_PIXIE 0x70000023
+#define SHT_MIPS_XLATE 0x70000024
+#define SHT_MIPS_XLATE_DEBUG 0x70000025
+#define SHT_MIPS_WHIRL 0x70000026
+#define SHT_MIPS_EH_REGION 0x70000027
+#define SHT_MIPS_XLATE_OLD 0x70000028
 #define SHT_MIPS_PDR_EXCEPTION 0x70000029
 
-
-
-#define SHF_MIPS_GPREL	 0x10000000
-#define SHF_MIPS_MERGE	 0x20000000
-#define SHF_MIPS_ADDR	 0x40000000
+#define SHF_MIPS_GPREL 0x10000000
+#define SHF_MIPS_MERGE 0x20000000
+#define SHF_MIPS_ADDR 0x40000000
 #define SHF_MIPS_STRINGS 0x80000000
 #define SHF_MIPS_NOSTRIP 0x08000000
-#define SHF_MIPS_LOCAL	 0x04000000
-#define SHF_MIPS_NAMES	 0x02000000
-#define SHF_MIPS_NODUPE	 0x01000000
-
-
-
-
-
-#define STO_MIPS_DEFAULT		0x0
-#define STO_MIPS_INTERNAL		0x1
-#define STO_MIPS_HIDDEN			0x2
-#define STO_MIPS_PROTECTED		0x3
-#define STO_MIPS_PLT			0x8
-#define STO_MIPS_SC_ALIGN_UNUSED	0xff
-
-
-#define STB_MIPS_SPLIT_COMMON		13
+#define SHF_MIPS_LOCAL 0x04000000
+#define SHF_MIPS_NAMES 0x02000000
+#define SHF_MIPS_NODUPE 0x01000000
 
+#define STO_MIPS_DEFAULT 0x0
+#define STO_MIPS_INTERNAL 0x1
+#define STO_MIPS_HIDDEN 0x2
+#define STO_MIPS_PROTECTED 0x3
+#define STO_MIPS_PLT 0x8
+#define STO_MIPS_SC_ALIGN_UNUSED 0xff
 
+#define STB_MIPS_SPLIT_COMMON 13
 
 typedef union {
-  struct {
-      Elf32_Word gt_current_g_value;
-      Elf32_Word gt_unused;
-  } gt_header;
-  struct {
-      Elf32_Word gt_g_value;
-      Elf32_Word gt_bytes;
-  } gt_entry;
+    struct {
+        Elf32_Word gt_current_g_value;
+        Elf32_Word gt_unused;
+    } gt_header;
+    struct {
+        Elf32_Word gt_g_value;
+        Elf32_Word gt_bytes;
+    } gt_entry;
 } Elf32_gptab;
 
-
-
 typedef struct {
-  Elf32_Word	ri_gprmask;
-  Elf32_Word	ri_cprmask[4];
-  Elf32_Sword	ri_gp_value;
+    Elf32_Word ri_gprmask;
+    Elf32_Word ri_cprmask[4];
+    Elf32_Sword ri_gp_value;
 } Elf32_RegInfo;
 
-
-
 typedef struct {
-  unsigned char kind;
+    unsigned char kind;
 
-  unsigned char size;
-  Elf32_Section section;
+    unsigned char size;
+    Elf32_Section section;
 
-  Elf32_Word info;
+    Elf32_Word info;
 } Elf_Options;
 
-
-
-#define ODK_NULL	0
-#define ODK_REGINFO	1
-#define ODK_EXCEPTIONS	2
-#define ODK_PAD		3
-#define ODK_HWPATCH	4
-#define ODK_FILL	5
-#define ODK_TAGS	6
-#define ODK_HWAND	7
-#define ODK_HWOR	8
-
-
-
-#define OEX_FPU_MIN	0x1f
-#define OEX_FPU_MAX	0x1f00
-#define OEX_PAGE0	0x10000
-#define OEX_SMM		0x20000
-#define OEX_FPDBUG	0x40000
-#define OEX_PRECISEFP	OEX_FPDBUG
-#define OEX_DISMISS	0x80000
-
-#define OEX_FPU_INVAL	0x10
-#define OEX_FPU_DIV0	0x08
-#define OEX_FPU_OFLO	0x04
-#define OEX_FPU_UFLO	0x02
-#define OEX_FPU_INEX	0x01
-
-
-
-#define OHW_R4KEOP	0x1
-#define OHW_R8KPFETCH	0x2
-#define OHW_R5KEOP	0x4
-#define OHW_R5KCVTL	0x8
-
-#define OPAD_PREFIX	0x1
-#define OPAD_POSTFIX	0x2
-#define OPAD_SYMBOL	0x4
-
-
+#define ODK_NULL 0
+#define ODK_REGINFO 1
+#define ODK_EXCEPTIONS 2
+#define ODK_PAD 3
+#define ODK_HWPATCH 4
+#define ODK_FILL 5
+#define ODK_TAGS 6
+#define ODK_HWAND 7
+#define ODK_HWOR 8
+
+#define OEX_FPU_MIN 0x1f
+#define OEX_FPU_MAX 0x1f00
+#define OEX_PAGE0 0x10000
+#define OEX_SMM 0x20000
+#define OEX_FPDBUG 0x40000
+#define OEX_PRECISEFP OEX_FPDBUG
+#define OEX_DISMISS 0x80000
+
+#define OEX_FPU_INVAL 0x10
+#define OEX_FPU_DIV0 0x08
+#define OEX_FPU_OFLO 0x04
+#define OEX_FPU_UFLO 0x02
+#define OEX_FPU_INEX 0x01
+
+#define OHW_R4KEOP 0x1
+#define OHW_R8KPFETCH 0x2
+#define OHW_R5KEOP 0x4
+#define OHW_R5KCVTL 0x8
+
+#define OPAD_PREFIX 0x1
+#define OPAD_POSTFIX 0x2
+#define OPAD_SYMBOL 0x4
 
 typedef struct {
-  Elf32_Word hwp_flags1;
-  Elf32_Word hwp_flags2;
+    Elf32_Word hwp_flags1;
+    Elf32_Word hwp_flags2;
 } Elf_Options_Hw;
 
-
-
-#define OHWA0_R4KEOP_CHECKED	0x00000001
-#define OHWA1_R4KEOP_CLEAN	0x00000002
-
-
-
-#define R_MIPS_NONE		0
-#define R_MIPS_16		1
-#define R_MIPS_32		2
-#define R_MIPS_REL32		3
-#define R_MIPS_26		4
-#define R_MIPS_HI16		5
-#define R_MIPS_LO16		6
-#define R_MIPS_GPREL16		7
-#define R_MIPS_LITERAL		8
-#define R_MIPS_GOT16		9
-#define R_MIPS_PC16		10
-#define R_MIPS_CALL16		11
-#define R_MIPS_GPREL32		12
-
-#define R_MIPS_SHIFT5		16
-#define R_MIPS_SHIFT6		17
-#define R_MIPS_64		18
-#define R_MIPS_GOT_DISP		19
-#define R_MIPS_GOT_PAGE		20
-#define R_MIPS_GOT_OFST		21
-#define R_MIPS_GOT_HI16		22
-#define R_MIPS_GOT_LO16		23
-#define R_MIPS_SUB		24
-#define R_MIPS_INSERT_A		25
-#define R_MIPS_INSERT_B		26
-#define R_MIPS_DELETE		27
-#define R_MIPS_HIGHER		28
-#define R_MIPS_HIGHEST		29
-#define R_MIPS_CALL_HI16	30
-#define R_MIPS_CALL_LO16	31
-#define R_MIPS_SCN_DISP		32
-#define R_MIPS_REL16		33
-#define R_MIPS_ADD_IMMEDIATE	34
-#define R_MIPS_PJUMP		35
-#define R_MIPS_RELGOT		36
-#define R_MIPS_JALR		37
-#define R_MIPS_TLS_DTPMOD32	38
-#define R_MIPS_TLS_DTPREL32	39
-#define R_MIPS_TLS_DTPMOD64	40
-#define R_MIPS_TLS_DTPREL64	41
-#define R_MIPS_TLS_GD		42
-#define R_MIPS_TLS_LDM		43
-#define R_MIPS_TLS_DTPREL_HI16	44
-#define R_MIPS_TLS_DTPREL_LO16	45
-#define R_MIPS_TLS_GOTTPREL	46
-#define R_MIPS_TLS_TPREL32	47
-#define R_MIPS_TLS_TPREL64	48
-#define R_MIPS_TLS_TPREL_HI16	49
-#define R_MIPS_TLS_TPREL_LO16	50
-#define R_MIPS_GLOB_DAT		51
-#define R_MIPS_COPY		126
-#define R_MIPS_JUMP_SLOT        127
-
-#define R_MIPS_NUM		128
-
-
-
-#define PT_MIPS_REGINFO	0x70000000
-#define PT_MIPS_RTPROC  0x70000001
+#define OHWA0_R4KEOP_CHECKED 0x00000001
+#define OHWA1_R4KEOP_CLEAN 0x00000002
+
+#define R_MIPS_NONE 0
+#define R_MIPS_16 1
+#define R_MIPS_32 2
+#define R_MIPS_REL32 3
+#define R_MIPS_26 4
+#define R_MIPS_HI16 5
+#define R_MIPS_LO16 6
+#define R_MIPS_GPREL16 7
+#define R_MIPS_LITERAL 8
+#define R_MIPS_GOT16 9
+#define R_MIPS_PC16 10
+#define R_MIPS_CALL16 11
+#define R_MIPS_GPREL32 12
+
+#define R_MIPS_SHIFT5 16
+#define R_MIPS_SHIFT6 17
+#define R_MIPS_64 18
+#define R_MIPS_GOT_DISP 19
+#define R_MIPS_GOT_PAGE 20
+#define R_MIPS_GOT_OFST 21
+#define R_MIPS_GOT_HI16 22
+#define R_MIPS_GOT_LO16 23
+#define R_MIPS_SUB 24
+#define R_MIPS_INSERT_A 25
+#define R_MIPS_INSERT_B 26
+#define R_MIPS_DELETE 27
+#define R_MIPS_HIGHER 28
+#define R_MIPS_HIGHEST 29
+#define R_MIPS_CALL_HI16 30
+#define R_MIPS_CALL_LO16 31
+#define R_MIPS_SCN_DISP 32
+#define R_MIPS_REL16 33
+#define R_MIPS_ADD_IMMEDIATE 34
+#define R_MIPS_PJUMP 35
+#define R_MIPS_RELGOT 36
+#define R_MIPS_JALR 37
+#define R_MIPS_TLS_DTPMOD32 38
+#define R_MIPS_TLS_DTPREL32 39
+#define R_MIPS_TLS_DTPMOD64 40
+#define R_MIPS_TLS_DTPREL64 41
+#define R_MIPS_TLS_GD 42
+#define R_MIPS_TLS_LDM 43
+#define R_MIPS_TLS_DTPREL_HI16 44
+#define R_MIPS_TLS_DTPREL_LO16 45
+#define R_MIPS_TLS_GOTTPREL 46
+#define R_MIPS_TLS_TPREL32 47
+#define R_MIPS_TLS_TPREL64 48
+#define R_MIPS_TLS_TPREL_HI16 49
+#define R_MIPS_TLS_TPREL_LO16 50
+#define R_MIPS_GLOB_DAT 51
+#define R_MIPS_COPY 126
+#define R_MIPS_JUMP_SLOT 127
+
+#define R_MIPS_NUM 128
+
+#define PT_MIPS_REGINFO 0x70000000
+#define PT_MIPS_RTPROC 0x70000001
 #define PT_MIPS_OPTIONS 0x70000002
 #define PT_MIPS_ABIFLAGS 0x70000003
 
+#define PF_MIPS_LOCAL 0x10000000
 
-
-#define PF_MIPS_LOCAL	0x10000000
-
-
-
-#define DT_MIPS_RLD_VERSION  0x70000001
-#define DT_MIPS_TIME_STAMP   0x70000002
-#define DT_MIPS_ICHECKSUM    0x70000003
-#define DT_MIPS_IVERSION     0x70000004
-#define DT_MIPS_FLAGS	     0x70000005
+#define DT_MIPS_RLD_VERSION 0x70000001
+#define DT_MIPS_TIME_STAMP 0x70000002
+#define DT_MIPS_ICHECKSUM 0x70000003
+#define DT_MIPS_IVERSION 0x70000004
+#define DT_MIPS_FLAGS 0x70000005
 #define DT_MIPS_BASE_ADDRESS 0x70000006
-#define DT_MIPS_MSYM	     0x70000007
-#define DT_MIPS_CONFLICT     0x70000008
-#define DT_MIPS_LIBLIST	     0x70000009
-#define DT_MIPS_LOCAL_GOTNO  0x7000000a
-#define DT_MIPS_CONFLICTNO   0x7000000b
-#define DT_MIPS_LIBLISTNO    0x70000010
-#define DT_MIPS_SYMTABNO     0x70000011
-#define DT_MIPS_UNREFEXTNO   0x70000012
-#define DT_MIPS_GOTSYM	     0x70000013
-#define DT_MIPS_HIPAGENO     0x70000014
-#define DT_MIPS_RLD_MAP	     0x70000016
-#define DT_MIPS_DELTA_CLASS  0x70000017
-#define DT_MIPS_DELTA_CLASS_NO    0x70000018
-
-#define DT_MIPS_DELTA_INSTANCE    0x70000019
+#define DT_MIPS_MSYM 0x70000007
+#define DT_MIPS_CONFLICT 0x70000008
+#define DT_MIPS_LIBLIST 0x70000009
+#define DT_MIPS_LOCAL_GOTNO 0x7000000a
+#define DT_MIPS_CONFLICTNO 0x7000000b
+#define DT_MIPS_LIBLISTNO 0x70000010
+#define DT_MIPS_SYMTABNO 0x70000011
+#define DT_MIPS_UNREFEXTNO 0x70000012
+#define DT_MIPS_GOTSYM 0x70000013
+#define DT_MIPS_HIPAGENO 0x70000014
+#define DT_MIPS_RLD_MAP 0x70000016
+#define DT_MIPS_DELTA_CLASS 0x70000017
+#define DT_MIPS_DELTA_CLASS_NO 0x70000018
+
+#define DT_MIPS_DELTA_INSTANCE 0x70000019
 #define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a
 
-#define DT_MIPS_DELTA_RELOC  0x7000001b
+#define DT_MIPS_DELTA_RELOC 0x7000001b
 #define DT_MIPS_DELTA_RELOC_NO 0x7000001c
 
-#define DT_MIPS_DELTA_SYM    0x7000001d
+#define DT_MIPS_DELTA_SYM 0x7000001d
 
 #define DT_MIPS_DELTA_SYM_NO 0x7000001e
 
@@ -1587,788 +1446,718 @@ typedef struct {
 
 #define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021
 
-#define DT_MIPS_CXX_FLAGS    0x70000022
-#define DT_MIPS_PIXIE_INIT   0x70000023
-#define DT_MIPS_SYMBOL_LIB   0x70000024
+#define DT_MIPS_CXX_FLAGS 0x70000022
+#define DT_MIPS_PIXIE_INIT 0x70000023
+#define DT_MIPS_SYMBOL_LIB 0x70000024
 #define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
 #define DT_MIPS_LOCAL_GOTIDX 0x70000026
 #define DT_MIPS_HIDDEN_GOTIDX 0x70000027
 #define DT_MIPS_PROTECTED_GOTIDX 0x70000028
-#define DT_MIPS_OPTIONS	     0x70000029
-#define DT_MIPS_INTERFACE    0x7000002a
+#define DT_MIPS_OPTIONS 0x70000029
+#define DT_MIPS_INTERFACE 0x7000002a
 #define DT_MIPS_DYNSTR_ALIGN 0x7000002b
 #define DT_MIPS_INTERFACE_SIZE 0x7000002c
 #define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d
 
-#define DT_MIPS_PERF_SUFFIX  0x7000002e
+#define DT_MIPS_PERF_SUFFIX 0x7000002e
 
 #define DT_MIPS_COMPACT_SIZE 0x7000002f
-#define DT_MIPS_GP_VALUE     0x70000030
-#define DT_MIPS_AUX_DYNAMIC  0x70000031
+#define DT_MIPS_GP_VALUE 0x70000030
+#define DT_MIPS_AUX_DYNAMIC 0x70000031
 
-#define DT_MIPS_PLTGOT	     0x70000032
+#define DT_MIPS_PLTGOT 0x70000032
 
-#define DT_MIPS_RWPLT        0x70000034
-#define DT_MIPS_RLD_MAP_REL  0x70000035
-#define DT_MIPS_NUM	     0x36
+#define DT_MIPS_RWPLT 0x70000034
+#define DT_MIPS_RLD_MAP_REL 0x70000035
+#define DT_MIPS_NUM 0x36
 
-
-
-#define RHF_NONE		   0
-#define RHF_QUICKSTART		   (1 << 0)
-#define RHF_NOTPOT		   (1 << 1)
+#define RHF_NONE 0
+#define RHF_QUICKSTART (1 << 0)
+#define RHF_NOTPOT (1 << 1)
 #define RHF_NO_LIBRARY_REPLACEMENT (1 << 2)
-#define RHF_NO_MOVE		   (1 << 3)
-#define RHF_SGI_ONLY		   (1 << 4)
-#define RHF_GUARANTEE_INIT	   (1 << 5)
-#define RHF_DELTA_C_PLUS_PLUS	   (1 << 6)
-#define RHF_GUARANTEE_START_INIT   (1 << 7)
-#define RHF_PIXIE		   (1 << 8)
-#define RHF_DEFAULT_DELAY_LOAD	   (1 << 9)
-#define RHF_REQUICKSTART	   (1 << 10)
-#define RHF_REQUICKSTARTED	   (1 << 11)
-#define RHF_CORD		   (1 << 12)
-#define RHF_NO_UNRES_UNDEF	   (1 << 13)
-#define RHF_RLD_ORDER_SAFE	   (1 << 14)
-
-
+#define RHF_NO_MOVE (1 << 3)
+#define RHF_SGI_ONLY (1 << 4)
+#define RHF_GUARANTEE_INIT (1 << 5)
+#define RHF_DELTA_C_PLUS_PLUS (1 << 6)
+#define RHF_GUARANTEE_START_INIT (1 << 7)
+#define RHF_PIXIE (1 << 8)
+#define RHF_DEFAULT_DELAY_LOAD (1 << 9)
+#define RHF_REQUICKSTART (1 << 10)
+#define RHF_REQUICKSTARTED (1 << 11)
+#define RHF_CORD (1 << 12)
+#define RHF_NO_UNRES_UNDEF (1 << 13)
+#define RHF_RLD_ORDER_SAFE (1 << 14)
 
 typedef struct {
-  Elf32_Word l_name;
-  Elf32_Word l_time_stamp;
-  Elf32_Word l_checksum;
-  Elf32_Word l_version;
-  Elf32_Word l_flags;
+    Elf32_Word l_name;
+    Elf32_Word l_time_stamp;
+    Elf32_Word l_checksum;
+    Elf32_Word l_version;
+    Elf32_Word l_flags;
 } Elf32_Lib;
 
 typedef struct {
-  Elf64_Word l_name;
-  Elf64_Word l_time_stamp;
-  Elf64_Word l_checksum;
-  Elf64_Word l_version;
-  Elf64_Word l_flags;
+    Elf64_Word l_name;
+    Elf64_Word l_time_stamp;
+    Elf64_Word l_checksum;
+    Elf64_Word l_version;
+    Elf64_Word l_flags;
 } Elf64_Lib;
 
-
-
-
-#define LL_NONE		  0
-#define LL_EXACT_MATCH	  (1 << 0)
+#define LL_NONE 0
+#define LL_EXACT_MATCH (1 << 0)
 #define LL_IGNORE_INT_VER (1 << 1)
-#define LL_REQUIRE_MINOR  (1 << 2)
-#define LL_EXPORTS	  (1 << 3)
-#define LL_DELAY_LOAD	  (1 << 4)
-#define LL_DELTA	  (1 << 5)
-
-
+#define LL_REQUIRE_MINOR (1 << 2)
+#define LL_EXPORTS (1 << 3)
+#define LL_DELAY_LOAD (1 << 4)
+#define LL_DELTA (1 << 5)
 
 typedef Elf32_Addr Elf32_Conflict;
 
 typedef struct {
-  Elf32_Half version;
-  unsigned char isa_level;
-  unsigned char isa_rev;
-  unsigned char gpr_size;
-  unsigned char cpr1_size;
-  unsigned char cpr2_size;
-  unsigned char fp_abi;
-  Elf32_Word isa_ext;
-  Elf32_Word ases;
-  Elf32_Word flags1;
-  Elf32_Word flags2;
+    Elf32_Half version;
+    unsigned char isa_level;
+    unsigned char isa_rev;
+    unsigned char gpr_size;
+    unsigned char cpr1_size;
+    unsigned char cpr2_size;
+    unsigned char fp_abi;
+    Elf32_Word isa_ext;
+    Elf32_Word ases;
+    Elf32_Word flags1;
+    Elf32_Word flags2;
 } Elf_MIPS_ABIFlags_v0;
 
-#define MIPS_AFL_REG_NONE	0x00
-#define MIPS_AFL_REG_32		0x01
-#define MIPS_AFL_REG_64		0x02
-#define MIPS_AFL_REG_128	0x03
-
-#define MIPS_AFL_ASE_DSP	0x00000001
-#define MIPS_AFL_ASE_DSPR2	0x00000002
-#define MIPS_AFL_ASE_EVA	0x00000004
-#define MIPS_AFL_ASE_MCU	0x00000008
-#define MIPS_AFL_ASE_MDMX	0x00000010
-#define MIPS_AFL_ASE_MIPS3D	0x00000020
-#define MIPS_AFL_ASE_MT		0x00000040
-#define MIPS_AFL_ASE_SMARTMIPS	0x00000080
-#define MIPS_AFL_ASE_VIRT	0x00000100
-#define MIPS_AFL_ASE_MSA	0x00000200
-#define MIPS_AFL_ASE_MIPS16	0x00000400
-#define MIPS_AFL_ASE_MICROMIPS	0x00000800
-#define MIPS_AFL_ASE_XPA	0x00001000
-#define MIPS_AFL_ASE_MASK	0x00001fff
-
-#define MIPS_AFL_EXT_XLR	  1
-#define MIPS_AFL_EXT_OCTEON2	  2
-#define MIPS_AFL_EXT_OCTEONP	  3
-#define MIPS_AFL_EXT_LOONGSON_3A  4
-#define MIPS_AFL_EXT_OCTEON	  5
-#define MIPS_AFL_EXT_5900	  6
-#define MIPS_AFL_EXT_4650	  7
-#define MIPS_AFL_EXT_4010	  8
-#define MIPS_AFL_EXT_4100	  9
-#define MIPS_AFL_EXT_3900	  10
-#define MIPS_AFL_EXT_10000	  11
-#define MIPS_AFL_EXT_SB1	  12
-#define MIPS_AFL_EXT_4111	  13
-#define MIPS_AFL_EXT_4120	  14
-#define MIPS_AFL_EXT_5400	  15
-#define MIPS_AFL_EXT_5500	  16
-#define MIPS_AFL_EXT_LOONGSON_2E  17
-#define MIPS_AFL_EXT_LOONGSON_2F  18
-
-#define MIPS_AFL_FLAGS1_ODDSPREG  1
-
-enum
-{
-  Val_GNU_MIPS_ABI_FP_ANY = 0,
-  Val_GNU_MIPS_ABI_FP_DOUBLE = 1,
-  Val_GNU_MIPS_ABI_FP_SINGLE = 2,
-  Val_GNU_MIPS_ABI_FP_SOFT = 3,
-  Val_GNU_MIPS_ABI_FP_OLD_64 = 4,
-  Val_GNU_MIPS_ABI_FP_XX = 5,
-  Val_GNU_MIPS_ABI_FP_64 = 6,
-  Val_GNU_MIPS_ABI_FP_64A = 7,
-  Val_GNU_MIPS_ABI_FP_MAX = 7
+#define MIPS_AFL_REG_NONE 0x00
+#define MIPS_AFL_REG_32 0x01
+#define MIPS_AFL_REG_64 0x02
+#define MIPS_AFL_REG_128 0x03
+
+#define MIPS_AFL_ASE_DSP 0x00000001
+#define MIPS_AFL_ASE_DSPR2 0x00000002
+#define MIPS_AFL_ASE_EVA 0x00000004
+#define MIPS_AFL_ASE_MCU 0x00000008
+#define MIPS_AFL_ASE_MDMX 0x00000010
+#define MIPS_AFL_ASE_MIPS3D 0x00000020
+#define MIPS_AFL_ASE_MT 0x00000040
+#define MIPS_AFL_ASE_SMARTMIPS 0x00000080
+#define MIPS_AFL_ASE_VIRT 0x00000100
+#define MIPS_AFL_ASE_MSA 0x00000200
+#define MIPS_AFL_ASE_MIPS16 0x00000400
+#define MIPS_AFL_ASE_MICROMIPS 0x00000800
+#define MIPS_AFL_ASE_XPA 0x00001000
+#define MIPS_AFL_ASE_MASK 0x00001fff
+
+#define MIPS_AFL_EXT_XLR 1
+#define MIPS_AFL_EXT_OCTEON2 2
+#define MIPS_AFL_EXT_OCTEONP 3
+#define MIPS_AFL_EXT_LOONGSON_3A 4
+#define MIPS_AFL_EXT_OCTEON 5
+#define MIPS_AFL_EXT_5900 6
+#define MIPS_AFL_EXT_4650 7
+#define MIPS_AFL_EXT_4010 8
+#define MIPS_AFL_EXT_4100 9
+#define MIPS_AFL_EXT_3900 10
+#define MIPS_AFL_EXT_10000 11
+#define MIPS_AFL_EXT_SB1 12
+#define MIPS_AFL_EXT_4111 13
+#define MIPS_AFL_EXT_4120 14
+#define MIPS_AFL_EXT_5400 15
+#define MIPS_AFL_EXT_5500 16
+#define MIPS_AFL_EXT_LOONGSON_2E 17
+#define MIPS_AFL_EXT_LOONGSON_2F 18
+
+#define MIPS_AFL_FLAGS1_ODDSPREG 1
+
+enum {
+    Val_GNU_MIPS_ABI_FP_ANY = 0,
+    Val_GNU_MIPS_ABI_FP_DOUBLE = 1,
+    Val_GNU_MIPS_ABI_FP_SINGLE = 2,
+    Val_GNU_MIPS_ABI_FP_SOFT = 3,
+    Val_GNU_MIPS_ABI_FP_OLD_64 = 4,
+    Val_GNU_MIPS_ABI_FP_XX = 5,
+    Val_GNU_MIPS_ABI_FP_64 = 6,
+    Val_GNU_MIPS_ABI_FP_64A = 7,
+    Val_GNU_MIPS_ABI_FP_MAX = 7
 };
 
-
-
-
-#define EF_PARISC_TRAPNIL	0x00010000
-#define EF_PARISC_EXT		0x00020000
-#define EF_PARISC_LSB		0x00040000
-#define EF_PARISC_WIDE		0x00080000
-#define EF_PARISC_NO_KABP	0x00100000
-
-#define EF_PARISC_LAZYSWAP	0x00400000
-#define EF_PARISC_ARCH		0x0000ffff
-
-
-
-#define EFA_PARISC_1_0		    0x020b
-#define EFA_PARISC_1_1		    0x0210
-#define EFA_PARISC_2_0		    0x0214
-
-
-
-#define SHN_PARISC_ANSI_COMMON	0xff00
-
-#define SHN_PARISC_HUGE_COMMON	0xff01
-
-
-
-#define SHT_PARISC_EXT		0x70000000
-#define SHT_PARISC_UNWIND	0x70000001
-#define SHT_PARISC_DOC		0x70000002
-
-
-
-#define SHF_PARISC_SHORT	0x20000000
-#define SHF_PARISC_HUGE		0x40000000
-#define SHF_PARISC_SBP		0x80000000
-
-
-
-#define STT_PARISC_MILLICODE	13
-
-#define STT_HP_OPAQUE		(STT_LOOS + 0x1)
-#define STT_HP_STUB		(STT_LOOS + 0x2)
-
-
-
-#define R_PARISC_NONE		0
-#define R_PARISC_DIR32		1
-#define R_PARISC_DIR21L		2
-#define R_PARISC_DIR17R		3
-#define R_PARISC_DIR17F		4
-#define R_PARISC_DIR14R		6
-#define R_PARISC_PCREL32	9
-#define R_PARISC_PCREL21L	10
-#define R_PARISC_PCREL17R	11
-#define R_PARISC_PCREL17F	12
-#define R_PARISC_PCREL14R	14
-#define R_PARISC_DPREL21L	18
-#define R_PARISC_DPREL14R	22
-#define R_PARISC_GPREL21L	26
-#define R_PARISC_GPREL14R	30
-#define R_PARISC_LTOFF21L	34
-#define R_PARISC_LTOFF14R	38
-#define R_PARISC_SECREL32	41
-#define R_PARISC_SEGBASE	48
-#define R_PARISC_SEGREL32	49
-#define R_PARISC_PLTOFF21L	50
-#define R_PARISC_PLTOFF14R	54
-#define R_PARISC_LTOFF_FPTR32	57
-#define R_PARISC_LTOFF_FPTR21L	58
-#define R_PARISC_LTOFF_FPTR14R	62
-#define R_PARISC_FPTR64		64
-#define R_PARISC_PLABEL32	65
-#define R_PARISC_PLABEL21L	66
-#define R_PARISC_PLABEL14R	70
-#define R_PARISC_PCREL64	72
-#define R_PARISC_PCREL22F	74
-#define R_PARISC_PCREL14WR	75
-#define R_PARISC_PCREL14DR	76
-#define R_PARISC_PCREL16F	77
-#define R_PARISC_PCREL16WF	78
-#define R_PARISC_PCREL16DF	79
-#define R_PARISC_DIR64		80
-#define R_PARISC_DIR14WR	83
-#define R_PARISC_DIR14DR	84
-#define R_PARISC_DIR16F		85
-#define R_PARISC_DIR16WF	86
-#define R_PARISC_DIR16DF	87
-#define R_PARISC_GPREL64	88
-#define R_PARISC_GPREL14WR	91
-#define R_PARISC_GPREL14DR	92
-#define R_PARISC_GPREL16F	93
-#define R_PARISC_GPREL16WF	94
-#define R_PARISC_GPREL16DF	95
-#define R_PARISC_LTOFF64	96
-#define R_PARISC_LTOFF14WR	99
-#define R_PARISC_LTOFF14DR	100
-#define R_PARISC_LTOFF16F	101
-#define R_PARISC_LTOFF16WF	102
-#define R_PARISC_LTOFF16DF	103
-#define R_PARISC_SECREL64	104
-#define R_PARISC_SEGREL64	112
-#define R_PARISC_PLTOFF14WR	115
-#define R_PARISC_PLTOFF14DR	116
-#define R_PARISC_PLTOFF16F	117
-#define R_PARISC_PLTOFF16WF	118
-#define R_PARISC_PLTOFF16DF	119
-#define R_PARISC_LTOFF_FPTR64	120
-#define R_PARISC_LTOFF_FPTR14WR	123
-#define R_PARISC_LTOFF_FPTR14DR	124
-#define R_PARISC_LTOFF_FPTR16F	125
-#define R_PARISC_LTOFF_FPTR16WF	126
-#define R_PARISC_LTOFF_FPTR16DF	127
-#define R_PARISC_LORESERVE	128
-#define R_PARISC_COPY		128
-#define R_PARISC_IPLT		129
-#define R_PARISC_EPLT		130
-#define R_PARISC_TPREL32	153
-#define R_PARISC_TPREL21L	154
-#define R_PARISC_TPREL14R	158
-#define R_PARISC_LTOFF_TP21L	162
-#define R_PARISC_LTOFF_TP14R	166
-#define R_PARISC_LTOFF_TP14F	167
-#define R_PARISC_TPREL64	216
-#define R_PARISC_TPREL14WR	219
-#define R_PARISC_TPREL14DR	220
-#define R_PARISC_TPREL16F	221
-#define R_PARISC_TPREL16WF	222
-#define R_PARISC_TPREL16DF	223
-#define R_PARISC_LTOFF_TP64	224
-#define R_PARISC_LTOFF_TP14WR	227
-#define R_PARISC_LTOFF_TP14DR	228
-#define R_PARISC_LTOFF_TP16F	229
-#define R_PARISC_LTOFF_TP16WF	230
-#define R_PARISC_LTOFF_TP16DF	231
-#define R_PARISC_GNU_VTENTRY	232
-#define R_PARISC_GNU_VTINHERIT	233
-#define R_PARISC_TLS_GD21L	234
-#define R_PARISC_TLS_GD14R	235
-#define R_PARISC_TLS_GDCALL	236
-#define R_PARISC_TLS_LDM21L	237
-#define R_PARISC_TLS_LDM14R	238
-#define R_PARISC_TLS_LDMCALL	239
-#define R_PARISC_TLS_LDO21L	240
-#define R_PARISC_TLS_LDO14R	241
-#define R_PARISC_TLS_DTPMOD32	242
-#define R_PARISC_TLS_DTPMOD64	243
-#define R_PARISC_TLS_DTPOFF32	244
-#define R_PARISC_TLS_DTPOFF64	245
-#define R_PARISC_TLS_LE21L	R_PARISC_TPREL21L
-#define R_PARISC_TLS_LE14R	R_PARISC_TPREL14R
-#define R_PARISC_TLS_IE21L	R_PARISC_LTOFF_TP21L
-#define R_PARISC_TLS_IE14R	R_PARISC_LTOFF_TP14R
-#define R_PARISC_TLS_TPREL32	R_PARISC_TPREL32
-#define R_PARISC_TLS_TPREL64	R_PARISC_TPREL64
-#define R_PARISC_HIRESERVE	255
-
-
-
-#define PT_HP_TLS		(PT_LOOS + 0x0)
-#define PT_HP_CORE_NONE		(PT_LOOS + 0x1)
-#define PT_HP_CORE_VERSION	(PT_LOOS + 0x2)
-#define PT_HP_CORE_KERNEL	(PT_LOOS + 0x3)
-#define PT_HP_CORE_COMM		(PT_LOOS + 0x4)
-#define PT_HP_CORE_PROC		(PT_LOOS + 0x5)
-#define PT_HP_CORE_LOADABLE	(PT_LOOS + 0x6)
-#define PT_HP_CORE_STACK	(PT_LOOS + 0x7)
-#define PT_HP_CORE_SHM		(PT_LOOS + 0x8)
-#define PT_HP_CORE_MMF		(PT_LOOS + 0x9)
-#define PT_HP_PARALLEL		(PT_LOOS + 0x10)
-#define PT_HP_FASTBIND		(PT_LOOS + 0x11)
-#define PT_HP_OPT_ANNOT		(PT_LOOS + 0x12)
-#define PT_HP_HSL_ANNOT		(PT_LOOS + 0x13)
-#define PT_HP_STACK		(PT_LOOS + 0x14)
-
-#define PT_PARISC_ARCHEXT	0x70000000
-#define PT_PARISC_UNWIND	0x70000001
-
-
-
-#define PF_PARISC_SBP		0x08000000
-
-#define PF_HP_PAGE_SIZE		0x00100000
-#define PF_HP_FAR_SHARED	0x00200000
-#define PF_HP_NEAR_SHARED	0x00400000
-#define PF_HP_CODE		0x01000000
-#define PF_HP_MODIFY		0x02000000
-#define PF_HP_LAZYSWAP		0x04000000
-#define PF_HP_SBP		0x08000000
-
-
-
-
-
-
-#define EF_ALPHA_32BIT		1
-#define EF_ALPHA_CANRELAX	2
-
-
-
-
-#define SHT_ALPHA_DEBUG		0x70000001
-#define SHT_ALPHA_REGINFO	0x70000002
-
-
-
-#define SHF_ALPHA_GPREL		0x10000000
-
-
-#define STO_ALPHA_NOPV		0x80
-#define STO_ALPHA_STD_GPLOAD	0x88
-
-
-
-#define R_ALPHA_NONE		0
-#define R_ALPHA_REFLONG		1
-#define R_ALPHA_REFQUAD		2
-#define R_ALPHA_GPREL32		3
-#define R_ALPHA_LITERAL		4
-#define R_ALPHA_LITUSE		5
-#define R_ALPHA_GPDISP		6
-#define R_ALPHA_BRADDR		7
-#define R_ALPHA_HINT		8
-#define R_ALPHA_SREL16		9
-#define R_ALPHA_SREL32		10
-#define R_ALPHA_SREL64		11
-#define R_ALPHA_GPRELHIGH	17
-#define R_ALPHA_GPRELLOW	18
-#define R_ALPHA_GPREL16		19
-#define R_ALPHA_COPY		24
-#define R_ALPHA_GLOB_DAT	25
-#define R_ALPHA_JMP_SLOT	26
-#define R_ALPHA_RELATIVE	27
-#define R_ALPHA_TLS_GD_HI	28
-#define R_ALPHA_TLSGD		29
-#define R_ALPHA_TLS_LDM		30
-#define R_ALPHA_DTPMOD64	31
-#define R_ALPHA_GOTDTPREL	32
-#define R_ALPHA_DTPREL64	33
-#define R_ALPHA_DTPRELHI	34
-#define R_ALPHA_DTPRELLO	35
-#define R_ALPHA_DTPREL16	36
-#define R_ALPHA_GOTTPREL	37
-#define R_ALPHA_TPREL64		38
-#define R_ALPHA_TPRELHI		39
-#define R_ALPHA_TPRELLO		40
-#define R_ALPHA_TPREL16		41
-
-#define R_ALPHA_NUM		46
-
-
-#define LITUSE_ALPHA_ADDR	0
-#define LITUSE_ALPHA_BASE	1
-#define LITUSE_ALPHA_BYTOFF	2
-#define LITUSE_ALPHA_JSR	3
-#define LITUSE_ALPHA_TLS_GD	4
-#define LITUSE_ALPHA_TLS_LDM	5
-
-
-#define DT_ALPHA_PLTRO		(DT_LOPROC + 0)
-#define DT_ALPHA_NUM		1
-
-
-
-
-#define EF_PPC_EMB		0x80000000
-
-
-#define EF_PPC_RELOCATABLE	0x00010000
-#define EF_PPC_RELOCATABLE_LIB	0x00008000
-
-
-
-#define R_PPC_NONE		0
-#define R_PPC_ADDR32		1
-#define R_PPC_ADDR24		2
-#define R_PPC_ADDR16		3
-#define R_PPC_ADDR16_LO		4
-#define R_PPC_ADDR16_HI		5
-#define R_PPC_ADDR16_HA		6
-#define R_PPC_ADDR14		7
-#define R_PPC_ADDR14_BRTAKEN	8
-#define R_PPC_ADDR14_BRNTAKEN	9
-#define R_PPC_REL24		10
-#define R_PPC_REL14		11
-#define R_PPC_REL14_BRTAKEN	12
-#define R_PPC_REL14_BRNTAKEN	13
-#define R_PPC_GOT16		14
-#define R_PPC_GOT16_LO		15
-#define R_PPC_GOT16_HI		16
-#define R_PPC_GOT16_HA		17
-#define R_PPC_PLTREL24		18
-#define R_PPC_COPY		19
-#define R_PPC_GLOB_DAT		20
-#define R_PPC_JMP_SLOT		21
-#define R_PPC_RELATIVE		22
-#define R_PPC_LOCAL24PC		23
-#define R_PPC_UADDR32		24
-#define R_PPC_UADDR16		25
-#define R_PPC_REL32		26
-#define R_PPC_PLT32		27
-#define R_PPC_PLTREL32		28
-#define R_PPC_PLT16_LO		29
-#define R_PPC_PLT16_HI		30
-#define R_PPC_PLT16_HA		31
-#define R_PPC_SDAREL16		32
-#define R_PPC_SECTOFF		33
-#define R_PPC_SECTOFF_LO	34
-#define R_PPC_SECTOFF_HI	35
-#define R_PPC_SECTOFF_HA	36
-
-
-#define R_PPC_TLS		67
-#define R_PPC_DTPMOD32		68
-#define R_PPC_TPREL16		69
-#define R_PPC_TPREL16_LO	70
-#define R_PPC_TPREL16_HI	71
-#define R_PPC_TPREL16_HA	72
-#define R_PPC_TPREL32		73
-#define R_PPC_DTPREL16		74
-#define R_PPC_DTPREL16_LO	75
-#define R_PPC_DTPREL16_HI	76
-#define R_PPC_DTPREL16_HA	77
-#define R_PPC_DTPREL32		78
-#define R_PPC_GOT_TLSGD16	79
-#define R_PPC_GOT_TLSGD16_LO	80
-#define R_PPC_GOT_TLSGD16_HI	81
-#define R_PPC_GOT_TLSGD16_HA	82
-#define R_PPC_GOT_TLSLD16	83
-#define R_PPC_GOT_TLSLD16_LO	84
-#define R_PPC_GOT_TLSLD16_HI	85
-#define R_PPC_GOT_TLSLD16_HA	86
-#define R_PPC_GOT_TPREL16	87
-#define R_PPC_GOT_TPREL16_LO	88
-#define R_PPC_GOT_TPREL16_HI	89
-#define R_PPC_GOT_TPREL16_HA	90
-#define R_PPC_GOT_DTPREL16	91
-#define R_PPC_GOT_DTPREL16_LO	92
-#define R_PPC_GOT_DTPREL16_HI	93
-#define R_PPC_GOT_DTPREL16_HA	94
-#define R_PPC_TLSGD		95
-#define R_PPC_TLSLD		96
-
-
-#define R_PPC_EMB_NADDR32	101
-#define R_PPC_EMB_NADDR16	102
-#define R_PPC_EMB_NADDR16_LO	103
-#define R_PPC_EMB_NADDR16_HI	104
-#define R_PPC_EMB_NADDR16_HA	105
-#define R_PPC_EMB_SDAI16	106
-#define R_PPC_EMB_SDA2I16	107
-#define R_PPC_EMB_SDA2REL	108
-#define R_PPC_EMB_SDA21		109
-#define R_PPC_EMB_MRKREF	110
-#define R_PPC_EMB_RELSEC16	111
-#define R_PPC_EMB_RELST_LO	112
-#define R_PPC_EMB_RELST_HI	113
-#define R_PPC_EMB_RELST_HA	114
-#define R_PPC_EMB_BIT_FLD	115
-#define R_PPC_EMB_RELSDA	116
-
-
-#define R_PPC_DIAB_SDA21_LO	180
-#define R_PPC_DIAB_SDA21_HI	181
-#define R_PPC_DIAB_SDA21_HA	182
-#define R_PPC_DIAB_RELSDA_LO	183
-#define R_PPC_DIAB_RELSDA_HI	184
-#define R_PPC_DIAB_RELSDA_HA	185
-
-
-#define R_PPC_IRELATIVE		248
-
-
-#define R_PPC_REL16		249
-#define R_PPC_REL16_LO		250
-#define R_PPC_REL16_HI		251
-#define R_PPC_REL16_HA		252
-
-
-
-#define R_PPC_TOC16		255
-
-
-#define DT_PPC_GOT		(DT_LOPROC + 0)
-#define DT_PPC_OPT		(DT_LOPROC + 1)
-#define DT_PPC_NUM		2
-
-#define PPC_OPT_TLS		1
-
-
-#define R_PPC64_NONE		R_PPC_NONE
-#define R_PPC64_ADDR32		R_PPC_ADDR32
-#define R_PPC64_ADDR24		R_PPC_ADDR24
-#define R_PPC64_ADDR16		R_PPC_ADDR16
-#define R_PPC64_ADDR16_LO	R_PPC_ADDR16_LO
-#define R_PPC64_ADDR16_HI	R_PPC_ADDR16_HI
-#define R_PPC64_ADDR16_HA	R_PPC_ADDR16_HA
-#define R_PPC64_ADDR14		R_PPC_ADDR14
-#define R_PPC64_ADDR14_BRTAKEN	R_PPC_ADDR14_BRTAKEN
-#define R_PPC64_ADDR14_BRNTAKEN	R_PPC_ADDR14_BRNTAKEN
-#define R_PPC64_REL24		R_PPC_REL24
-#define R_PPC64_REL14		R_PPC_REL14
-#define R_PPC64_REL14_BRTAKEN	R_PPC_REL14_BRTAKEN
-#define R_PPC64_REL14_BRNTAKEN	R_PPC_REL14_BRNTAKEN
-#define R_PPC64_GOT16		R_PPC_GOT16
-#define R_PPC64_GOT16_LO	R_PPC_GOT16_LO
-#define R_PPC64_GOT16_HI	R_PPC_GOT16_HI
-#define R_PPC64_GOT16_HA	R_PPC_GOT16_HA
-
-#define R_PPC64_COPY		R_PPC_COPY
-#define R_PPC64_GLOB_DAT	R_PPC_GLOB_DAT
-#define R_PPC64_JMP_SLOT	R_PPC_JMP_SLOT
-#define R_PPC64_RELATIVE	R_PPC_RELATIVE
-
-#define R_PPC64_UADDR32		R_PPC_UADDR32
-#define R_PPC64_UADDR16		R_PPC_UADDR16
-#define R_PPC64_REL32		R_PPC_REL32
-#define R_PPC64_PLT32		R_PPC_PLT32
-#define R_PPC64_PLTREL32	R_PPC_PLTREL32
-#define R_PPC64_PLT16_LO	R_PPC_PLT16_LO
-#define R_PPC64_PLT16_HI	R_PPC_PLT16_HI
-#define R_PPC64_PLT16_HA	R_PPC_PLT16_HA
-
-#define R_PPC64_SECTOFF		R_PPC_SECTOFF
-#define R_PPC64_SECTOFF_LO	R_PPC_SECTOFF_LO
-#define R_PPC64_SECTOFF_HI	R_PPC_SECTOFF_HI
-#define R_PPC64_SECTOFF_HA	R_PPC_SECTOFF_HA
-#define R_PPC64_ADDR30		37
-#define R_PPC64_ADDR64		38
-#define R_PPC64_ADDR16_HIGHER	39
-#define R_PPC64_ADDR16_HIGHERA	40
-#define R_PPC64_ADDR16_HIGHEST	41
-#define R_PPC64_ADDR16_HIGHESTA	42
-#define R_PPC64_UADDR64		43
-#define R_PPC64_REL64		44
-#define R_PPC64_PLT64		45
-#define R_PPC64_PLTREL64	46
-#define R_PPC64_TOC16		47
-#define R_PPC64_TOC16_LO	48
-#define R_PPC64_TOC16_HI	49
-#define R_PPC64_TOC16_HA	50
-#define R_PPC64_TOC		51
-#define R_PPC64_PLTGOT16	52
-#define R_PPC64_PLTGOT16_LO	53
-#define R_PPC64_PLTGOT16_HI	54
-#define R_PPC64_PLTGOT16_HA	55
-
-#define R_PPC64_ADDR16_DS	56
-#define R_PPC64_ADDR16_LO_DS	57
-#define R_PPC64_GOT16_DS	58
-#define R_PPC64_GOT16_LO_DS	59
-#define R_PPC64_PLT16_LO_DS	60
-#define R_PPC64_SECTOFF_DS	61
-#define R_PPC64_SECTOFF_LO_DS	62
-#define R_PPC64_TOC16_DS	63
-#define R_PPC64_TOC16_LO_DS	64
-#define R_PPC64_PLTGOT16_DS	65
-#define R_PPC64_PLTGOT16_LO_DS	66
-
-
-#define R_PPC64_TLS		67
-#define R_PPC64_DTPMOD64	68
-#define R_PPC64_TPREL16		69
-#define R_PPC64_TPREL16_LO	70
-#define R_PPC64_TPREL16_HI	71
-#define R_PPC64_TPREL16_HA	72
-#define R_PPC64_TPREL64		73
-#define R_PPC64_DTPREL16	74
-#define R_PPC64_DTPREL16_LO	75
-#define R_PPC64_DTPREL16_HI	76
-#define R_PPC64_DTPREL16_HA	77
-#define R_PPC64_DTPREL64	78
-#define R_PPC64_GOT_TLSGD16	79
-#define R_PPC64_GOT_TLSGD16_LO	80
-#define R_PPC64_GOT_TLSGD16_HI	81
-#define R_PPC64_GOT_TLSGD16_HA	82
-#define R_PPC64_GOT_TLSLD16	83
-#define R_PPC64_GOT_TLSLD16_LO	84
-#define R_PPC64_GOT_TLSLD16_HI	85
-#define R_PPC64_GOT_TLSLD16_HA	86
-#define R_PPC64_GOT_TPREL16_DS	87
+#define EF_PARISC_TRAPNIL 0x00010000
+#define EF_PARISC_EXT 0x00020000
+#define EF_PARISC_LSB 0x00040000
+#define EF_PARISC_WIDE 0x00080000
+#define EF_PARISC_NO_KABP 0x00100000
+
+#define EF_PARISC_LAZYSWAP 0x00400000
+#define EF_PARISC_ARCH 0x0000ffff
+
+#define EFA_PARISC_1_0 0x020b
+#define EFA_PARISC_1_1 0x0210
+#define EFA_PARISC_2_0 0x0214
+
+#define SHN_PARISC_ANSI_COMMON 0xff00
+
+#define SHN_PARISC_HUGE_COMMON 0xff01
+
+#define SHT_PARISC_EXT 0x70000000
+#define SHT_PARISC_UNWIND 0x70000001
+#define SHT_PARISC_DOC 0x70000002
+
+#define SHF_PARISC_SHORT 0x20000000
+#define SHF_PARISC_HUGE 0x40000000
+#define SHF_PARISC_SBP 0x80000000
+
+#define STT_PARISC_MILLICODE 13
+
+#define STT_HP_OPAQUE (STT_LOOS + 0x1)
+#define STT_HP_STUB (STT_LOOS + 0x2)
+
+#define R_PARISC_NONE 0
+#define R_PARISC_DIR32 1
+#define R_PARISC_DIR21L 2
+#define R_PARISC_DIR17R 3
+#define R_PARISC_DIR17F 4
+#define R_PARISC_DIR14R 6
+#define R_PARISC_PCREL32 9
+#define R_PARISC_PCREL21L 10
+#define R_PARISC_PCREL17R 11
+#define R_PARISC_PCREL17F 12
+#define R_PARISC_PCREL14R 14
+#define R_PARISC_DPREL21L 18
+#define R_PARISC_DPREL14R 22
+#define R_PARISC_GPREL21L 26
+#define R_PARISC_GPREL14R 30
+#define R_PARISC_LTOFF21L 34
+#define R_PARISC_LTOFF14R 38
+#define R_PARISC_SECREL32 41
+#define R_PARISC_SEGBASE 48
+#define R_PARISC_SEGREL32 49
+#define R_PARISC_PLTOFF21L 50
+#define R_PARISC_PLTOFF14R 54
+#define R_PARISC_LTOFF_FPTR32 57
+#define R_PARISC_LTOFF_FPTR21L 58
+#define R_PARISC_LTOFF_FPTR14R 62
+#define R_PARISC_FPTR64 64
+#define R_PARISC_PLABEL32 65
+#define R_PARISC_PLABEL21L 66
+#define R_PARISC_PLABEL14R 70
+#define R_PARISC_PCREL64 72
+#define R_PARISC_PCREL22F 74
+#define R_PARISC_PCREL14WR 75
+#define R_PARISC_PCREL14DR 76
+#define R_PARISC_PCREL16F 77
+#define R_PARISC_PCREL16WF 78
+#define R_PARISC_PCREL16DF 79
+#define R_PARISC_DIR64 80
+#define R_PARISC_DIR14WR 83
+#define R_PARISC_DIR14DR 84
+#define R_PARISC_DIR16F 85
+#define R_PARISC_DIR16WF 86
+#define R_PARISC_DIR16DF 87
+#define R_PARISC_GPREL64 88
+#define R_PARISC_GPREL14WR 91
+#define R_PARISC_GPREL14DR 92
+#define R_PARISC_GPREL16F 93
+#define R_PARISC_GPREL16WF 94
+#define R_PARISC_GPREL16DF 95
+#define R_PARISC_LTOFF64 96
+#define R_PARISC_LTOFF14WR 99
+#define R_PARISC_LTOFF14DR 100
+#define R_PARISC_LTOFF16F 101
+#define R_PARISC_LTOFF16WF 102
+#define R_PARISC_LTOFF16DF 103
+#define R_PARISC_SECREL64 104
+#define R_PARISC_SEGREL64 112
+#define R_PARISC_PLTOFF14WR 115
+#define R_PARISC_PLTOFF14DR 116
+#define R_PARISC_PLTOFF16F 117
+#define R_PARISC_PLTOFF16WF 118
+#define R_PARISC_PLTOFF16DF 119
+#define R_PARISC_LTOFF_FPTR64 120
+#define R_PARISC_LTOFF_FPTR14WR 123
+#define R_PARISC_LTOFF_FPTR14DR 124
+#define R_PARISC_LTOFF_FPTR16F 125
+#define R_PARISC_LTOFF_FPTR16WF 126
+#define R_PARISC_LTOFF_FPTR16DF 127
+#define R_PARISC_LORESERVE 128
+#define R_PARISC_COPY 128
+#define R_PARISC_IPLT 129
+#define R_PARISC_EPLT 130
+#define R_PARISC_TPREL32 153
+#define R_PARISC_TPREL21L 154
+#define R_PARISC_TPREL14R 158
+#define R_PARISC_LTOFF_TP21L 162
+#define R_PARISC_LTOFF_TP14R 166
+#define R_PARISC_LTOFF_TP14F 167
+#define R_PARISC_TPREL64 216
+#define R_PARISC_TPREL14WR 219
+#define R_PARISC_TPREL14DR 220
+#define R_PARISC_TPREL16F 221
+#define R_PARISC_TPREL16WF 222
+#define R_PARISC_TPREL16DF 223
+#define R_PARISC_LTOFF_TP64 224
+#define R_PARISC_LTOFF_TP14WR 227
+#define R_PARISC_LTOFF_TP14DR 228
+#define R_PARISC_LTOFF_TP16F 229
+#define R_PARISC_LTOFF_TP16WF 230
+#define R_PARISC_LTOFF_TP16DF 231
+#define R_PARISC_GNU_VTENTRY 232
+#define R_PARISC_GNU_VTINHERIT 233
+#define R_PARISC_TLS_GD21L 234
+#define R_PARISC_TLS_GD14R 235
+#define R_PARISC_TLS_GDCALL 236
+#define R_PARISC_TLS_LDM21L 237
+#define R_PARISC_TLS_LDM14R 238
+#define R_PARISC_TLS_LDMCALL 239
+#define R_PARISC_TLS_LDO21L 240
+#define R_PARISC_TLS_LDO14R 241
+#define R_PARISC_TLS_DTPMOD32 242
+#define R_PARISC_TLS_DTPMOD64 243
+#define R_PARISC_TLS_DTPOFF32 244
+#define R_PARISC_TLS_DTPOFF64 245
+#define R_PARISC_TLS_LE21L R_PARISC_TPREL21L
+#define R_PARISC_TLS_LE14R R_PARISC_TPREL14R
+#define R_PARISC_TLS_IE21L R_PARISC_LTOFF_TP21L
+#define R_PARISC_TLS_IE14R R_PARISC_LTOFF_TP14R
+#define R_PARISC_TLS_TPREL32 R_PARISC_TPREL32
+#define R_PARISC_TLS_TPREL64 R_PARISC_TPREL64
+#define R_PARISC_HIRESERVE 255
+
+#define PT_HP_TLS (PT_LOOS + 0x0)
+#define PT_HP_CORE_NONE (PT_LOOS + 0x1)
+#define PT_HP_CORE_VERSION (PT_LOOS + 0x2)
+#define PT_HP_CORE_KERNEL (PT_LOOS + 0x3)
+#define PT_HP_CORE_COMM (PT_LOOS + 0x4)
+#define PT_HP_CORE_PROC (PT_LOOS + 0x5)
+#define PT_HP_CORE_LOADABLE (PT_LOOS + 0x6)
+#define PT_HP_CORE_STACK (PT_LOOS + 0x7)
+#define PT_HP_CORE_SHM (PT_LOOS + 0x8)
+#define PT_HP_CORE_MMF (PT_LOOS + 0x9)
+#define PT_HP_PARALLEL (PT_LOOS + 0x10)
+#define PT_HP_FASTBIND (PT_LOOS + 0x11)
+#define PT_HP_OPT_ANNOT (PT_LOOS + 0x12)
+#define PT_HP_HSL_ANNOT (PT_LOOS + 0x13)
+#define PT_HP_STACK (PT_LOOS + 0x14)
+
+#define PT_PARISC_ARCHEXT 0x70000000
+#define PT_PARISC_UNWIND 0x70000001
+
+#define PF_PARISC_SBP 0x08000000
+
+#define PF_HP_PAGE_SIZE 0x00100000
+#define PF_HP_FAR_SHARED 0x00200000
+#define PF_HP_NEAR_SHARED 0x00400000
+#define PF_HP_CODE 0x01000000
+#define PF_HP_MODIFY 0x02000000
+#define PF_HP_LAZYSWAP 0x04000000
+#define PF_HP_SBP 0x08000000
+
+#define EF_ALPHA_32BIT 1
+#define EF_ALPHA_CANRELAX 2
+
+#define SHT_ALPHA_DEBUG 0x70000001
+#define SHT_ALPHA_REGINFO 0x70000002
+
+#define SHF_ALPHA_GPREL 0x10000000
+
+#define STO_ALPHA_NOPV 0x80
+#define STO_ALPHA_STD_GPLOAD 0x88
+
+#define R_ALPHA_NONE 0
+#define R_ALPHA_REFLONG 1
+#define R_ALPHA_REFQUAD 2
+#define R_ALPHA_GPREL32 3
+#define R_ALPHA_LITERAL 4
+#define R_ALPHA_LITUSE 5
+#define R_ALPHA_GPDISP 6
+#define R_ALPHA_BRADDR 7
+#define R_ALPHA_HINT 8
+#define R_ALPHA_SREL16 9
+#define R_ALPHA_SREL32 10
+#define R_ALPHA_SREL64 11
+#define R_ALPHA_GPRELHIGH 17
+#define R_ALPHA_GPRELLOW 18
+#define R_ALPHA_GPREL16 19
+#define R_ALPHA_COPY 24
+#define R_ALPHA_GLOB_DAT 25
+#define R_ALPHA_JMP_SLOT 26
+#define R_ALPHA_RELATIVE 27
+#define R_ALPHA_TLS_GD_HI 28
+#define R_ALPHA_TLSGD 29
+#define R_ALPHA_TLS_LDM 30
+#define R_ALPHA_DTPMOD64 31
+#define R_ALPHA_GOTDTPREL 32
+#define R_ALPHA_DTPREL64 33
+#define R_ALPHA_DTPRELHI 34
+#define R_ALPHA_DTPRELLO 35
+#define R_ALPHA_DTPREL16 36
+#define R_ALPHA_GOTTPREL 37
+#define R_ALPHA_TPREL64 38
+#define R_ALPHA_TPRELHI 39
+#define R_ALPHA_TPRELLO 40
+#define R_ALPHA_TPREL16 41
+
+#define R_ALPHA_NUM 46
+
+#define LITUSE_ALPHA_ADDR 0
+#define LITUSE_ALPHA_BASE 1
+#define LITUSE_ALPHA_BYTOFF 2
+#define LITUSE_ALPHA_JSR 3
+#define LITUSE_ALPHA_TLS_GD 4
+#define LITUSE_ALPHA_TLS_LDM 5
+
+#define DT_ALPHA_PLTRO (DT_LOPROC + 0)
+#define DT_ALPHA_NUM 1
+
+#define EF_PPC_EMB 0x80000000
+
+#define EF_PPC_RELOCATABLE 0x00010000
+#define EF_PPC_RELOCATABLE_LIB 0x00008000
+
+#define R_PPC_NONE 0
+#define R_PPC_ADDR32 1
+#define R_PPC_ADDR24 2
+#define R_PPC_ADDR16 3
+#define R_PPC_ADDR16_LO 4
+#define R_PPC_ADDR16_HI 5
+#define R_PPC_ADDR16_HA 6
+#define R_PPC_ADDR14 7
+#define R_PPC_ADDR14_BRTAKEN 8
+#define R_PPC_ADDR14_BRNTAKEN 9
+#define R_PPC_REL24 10
+#define R_PPC_REL14 11
+#define R_PPC_REL14_BRTAKEN 12
+#define R_PPC_REL14_BRNTAKEN 13
+#define R_PPC_GOT16 14
+#define R_PPC_GOT16_LO 15
+#define R_PPC_GOT16_HI 16
+#define R_PPC_GOT16_HA 17
+#define R_PPC_PLTREL24 18
+#define R_PPC_COPY 19
+#define R_PPC_GLOB_DAT 20
+#define R_PPC_JMP_SLOT 21
+#define R_PPC_RELATIVE 22
+#define R_PPC_LOCAL24PC 23
+#define R_PPC_UADDR32 24
+#define R_PPC_UADDR16 25
+#define R_PPC_REL32 26
+#define R_PPC_PLT32 27
+#define R_PPC_PLTREL32 28
+#define R_PPC_PLT16_LO 29
+#define R_PPC_PLT16_HI 30
+#define R_PPC_PLT16_HA 31
+#define R_PPC_SDAREL16 32
+#define R_PPC_SECTOFF 33
+#define R_PPC_SECTOFF_LO 34
+#define R_PPC_SECTOFF_HI 35
+#define R_PPC_SECTOFF_HA 36
+
+#define R_PPC_TLS 67
+#define R_PPC_DTPMOD32 68
+#define R_PPC_TPREL16 69
+#define R_PPC_TPREL16_LO 70
+#define R_PPC_TPREL16_HI 71
+#define R_PPC_TPREL16_HA 72
+#define R_PPC_TPREL32 73
+#define R_PPC_DTPREL16 74
+#define R_PPC_DTPREL16_LO 75
+#define R_PPC_DTPREL16_HI 76
+#define R_PPC_DTPREL16_HA 77
+#define R_PPC_DTPREL32 78
+#define R_PPC_GOT_TLSGD16 79
+#define R_PPC_GOT_TLSGD16_LO 80
+#define R_PPC_GOT_TLSGD16_HI 81
+#define R_PPC_GOT_TLSGD16_HA 82
+#define R_PPC_GOT_TLSLD16 83
+#define R_PPC_GOT_TLSLD16_LO 84
+#define R_PPC_GOT_TLSLD16_HI 85
+#define R_PPC_GOT_TLSLD16_HA 86
+#define R_PPC_GOT_TPREL16 87
+#define R_PPC_GOT_TPREL16_LO 88
+#define R_PPC_GOT_TPREL16_HI 89
+#define R_PPC_GOT_TPREL16_HA 90
+#define R_PPC_GOT_DTPREL16 91
+#define R_PPC_GOT_DTPREL16_LO 92
+#define R_PPC_GOT_DTPREL16_HI 93
+#define R_PPC_GOT_DTPREL16_HA 94
+#define R_PPC_TLSGD 95
+#define R_PPC_TLSLD 96
+
+#define R_PPC_EMB_NADDR32 101
+#define R_PPC_EMB_NADDR16 102
+#define R_PPC_EMB_NADDR16_LO 103
+#define R_PPC_EMB_NADDR16_HI 104
+#define R_PPC_EMB_NADDR16_HA 105
+#define R_PPC_EMB_SDAI16 106
+#define R_PPC_EMB_SDA2I16 107
+#define R_PPC_EMB_SDA2REL 108
+#define R_PPC_EMB_SDA21 109
+#define R_PPC_EMB_MRKREF 110
+#define R_PPC_EMB_RELSEC16 111
+#define R_PPC_EMB_RELST_LO 112
+#define R_PPC_EMB_RELST_HI 113
+#define R_PPC_EMB_RELST_HA 114
+#define R_PPC_EMB_BIT_FLD 115
+#define R_PPC_EMB_RELSDA 116
+
+#define R_PPC_DIAB_SDA21_LO 180
+#define R_PPC_DIAB_SDA21_HI 181
+#define R_PPC_DIAB_SDA21_HA 182
+#define R_PPC_DIAB_RELSDA_LO 183
+#define R_PPC_DIAB_RELSDA_HI 184
+#define R_PPC_DIAB_RELSDA_HA 185
+
+#define R_PPC_IRELATIVE 248
+
+#define R_PPC_REL16 249
+#define R_PPC_REL16_LO 250
+#define R_PPC_REL16_HI 251
+#define R_PPC_REL16_HA 252
+
+#define R_PPC_TOC16 255
+
+#define DT_PPC_GOT (DT_LOPROC + 0)
+#define DT_PPC_OPT (DT_LOPROC + 1)
+#define DT_PPC_NUM 2
+
+#define PPC_OPT_TLS 1
+
+#define R_PPC64_NONE R_PPC_NONE
+#define R_PPC64_ADDR32 R_PPC_ADDR32
+#define R_PPC64_ADDR24 R_PPC_ADDR24
+#define R_PPC64_ADDR16 R_PPC_ADDR16
+#define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO
+#define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI
+#define R_PPC64_ADDR16_HA R_PPC_ADDR16_HA
+#define R_PPC64_ADDR14 R_PPC_ADDR14
+#define R_PPC64_ADDR14_BRTAKEN R_PPC_ADDR14_BRTAKEN
+#define R_PPC64_ADDR14_BRNTAKEN R_PPC_ADDR14_BRNTAKEN
+#define R_PPC64_REL24 R_PPC_REL24
+#define R_PPC64_REL14 R_PPC_REL14
+#define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN
+#define R_PPC64_REL14_BRNTAKEN R_PPC_REL14_BRNTAKEN
+#define R_PPC64_GOT16 R_PPC_GOT16
+#define R_PPC64_GOT16_LO R_PPC_GOT16_LO
+#define R_PPC64_GOT16_HI R_PPC_GOT16_HI
+#define R_PPC64_GOT16_HA R_PPC_GOT16_HA
+
+#define R_PPC64_COPY R_PPC_COPY
+#define R_PPC64_GLOB_DAT R_PPC_GLOB_DAT
+#define R_PPC64_JMP_SLOT R_PPC_JMP_SLOT
+#define R_PPC64_RELATIVE R_PPC_RELATIVE
+
+#define R_PPC64_UADDR32 R_PPC_UADDR32
+#define R_PPC64_UADDR16 R_PPC_UADDR16
+#define R_PPC64_REL32 R_PPC_REL32
+#define R_PPC64_PLT32 R_PPC_PLT32
+#define R_PPC64_PLTREL32 R_PPC_PLTREL32
+#define R_PPC64_PLT16_LO R_PPC_PLT16_LO
+#define R_PPC64_PLT16_HI R_PPC_PLT16_HI
+#define R_PPC64_PLT16_HA R_PPC_PLT16_HA
+
+#define R_PPC64_SECTOFF R_PPC_SECTOFF
+#define R_PPC64_SECTOFF_LO R_PPC_SECTOFF_LO
+#define R_PPC64_SECTOFF_HI R_PPC_SECTOFF_HI
+#define R_PPC64_SECTOFF_HA R_PPC_SECTOFF_HA
+#define R_PPC64_ADDR30 37
+#define R_PPC64_ADDR64 38
+#define R_PPC64_ADDR16_HIGHER 39
+#define R_PPC64_ADDR16_HIGHERA 40
+#define R_PPC64_ADDR16_HIGHEST 41
+#define R_PPC64_ADDR16_HIGHESTA 42
+#define R_PPC64_UADDR64 43
+#define R_PPC64_REL64 44
+#define R_PPC64_PLT64 45
+#define R_PPC64_PLTREL64 46
+#define R_PPC64_TOC16 47
+#define R_PPC64_TOC16_LO 48
+#define R_PPC64_TOC16_HI 49
+#define R_PPC64_TOC16_HA 50
+#define R_PPC64_TOC 51
+#define R_PPC64_PLTGOT16 52
+#define R_PPC64_PLTGOT16_LO 53
+#define R_PPC64_PLTGOT16_HI 54
+#define R_PPC64_PLTGOT16_HA 55
+
+#define R_PPC64_ADDR16_DS 56
+#define R_PPC64_ADDR16_LO_DS 57
+#define R_PPC64_GOT16_DS 58
+#define R_PPC64_GOT16_LO_DS 59
+#define R_PPC64_PLT16_LO_DS 60
+#define R_PPC64_SECTOFF_DS 61
+#define R_PPC64_SECTOFF_LO_DS 62
+#define R_PPC64_TOC16_DS 63
+#define R_PPC64_TOC16_LO_DS 64
+#define R_PPC64_PLTGOT16_DS 65
+#define R_PPC64_PLTGOT16_LO_DS 66
+
+#define R_PPC64_TLS 67
+#define R_PPC64_DTPMOD64 68
+#define R_PPC64_TPREL16 69
+#define R_PPC64_TPREL16_LO 70
+#define R_PPC64_TPREL16_HI 71
+#define R_PPC64_TPREL16_HA 72
+#define R_PPC64_TPREL64 73
+#define R_PPC64_DTPREL16 74
+#define R_PPC64_DTPREL16_LO 75
+#define R_PPC64_DTPREL16_HI 76
+#define R_PPC64_DTPREL16_HA 77
+#define R_PPC64_DTPREL64 78
+#define R_PPC64_GOT_TLSGD16 79
+#define R_PPC64_GOT_TLSGD16_LO 80
+#define R_PPC64_GOT_TLSGD16_HI 81
+#define R_PPC64_GOT_TLSGD16_HA 82
+#define R_PPC64_GOT_TLSLD16 83
+#define R_PPC64_GOT_TLSLD16_LO 84
+#define R_PPC64_GOT_TLSLD16_HI 85
+#define R_PPC64_GOT_TLSLD16_HA 86
+#define R_PPC64_GOT_TPREL16_DS 87
 #define R_PPC64_GOT_TPREL16_LO_DS 88
-#define R_PPC64_GOT_TPREL16_HI	89
-#define R_PPC64_GOT_TPREL16_HA	90
-#define R_PPC64_GOT_DTPREL16_DS	91
+#define R_PPC64_GOT_TPREL16_HI 89
+#define R_PPC64_GOT_TPREL16_HA 90
+#define R_PPC64_GOT_DTPREL16_DS 91
 #define R_PPC64_GOT_DTPREL16_LO_DS 92
-#define R_PPC64_GOT_DTPREL16_HI	93
-#define R_PPC64_GOT_DTPREL16_HA	94
-#define R_PPC64_TPREL16_DS	95
-#define R_PPC64_TPREL16_LO_DS	96
-#define R_PPC64_TPREL16_HIGHER	97
-#define R_PPC64_TPREL16_HIGHERA	98
-#define R_PPC64_TPREL16_HIGHEST	99
+#define R_PPC64_GOT_DTPREL16_HI 93
+#define R_PPC64_GOT_DTPREL16_HA 94
+#define R_PPC64_TPREL16_DS 95
+#define R_PPC64_TPREL16_LO_DS 96
+#define R_PPC64_TPREL16_HIGHER 97
+#define R_PPC64_TPREL16_HIGHERA 98
+#define R_PPC64_TPREL16_HIGHEST 99
 #define R_PPC64_TPREL16_HIGHESTA 100
-#define R_PPC64_DTPREL16_DS	101
-#define R_PPC64_DTPREL16_LO_DS	102
-#define R_PPC64_DTPREL16_HIGHER	103
+#define R_PPC64_DTPREL16_DS 101
+#define R_PPC64_DTPREL16_LO_DS 102
+#define R_PPC64_DTPREL16_HIGHER 103
 #define R_PPC64_DTPREL16_HIGHERA 104
 #define R_PPC64_DTPREL16_HIGHEST 105
 #define R_PPC64_DTPREL16_HIGHESTA 106
-#define R_PPC64_TLSGD		107
-#define R_PPC64_TLSLD		108
-#define R_PPC64_TOCSAVE		109
-#define R_PPC64_ADDR16_HIGH	110
-#define R_PPC64_ADDR16_HIGHA	111
-#define R_PPC64_TPREL16_HIGH	112
-#define R_PPC64_TPREL16_HIGHA	113
-#define R_PPC64_DTPREL16_HIGH	114
-#define R_PPC64_DTPREL16_HIGHA	115
-
-
-#define R_PPC64_JMP_IREL	247
-#define R_PPC64_IRELATIVE	248
-#define R_PPC64_REL16		249
-#define R_PPC64_REL16_LO	250
-#define R_PPC64_REL16_HI	251
-#define R_PPC64_REL16_HA	252
-
-#define EF_PPC64_ABI	3
-
-#define DT_PPC64_GLINK  (DT_LOPROC + 0)
-#define DT_PPC64_OPD	(DT_LOPROC + 1)
-#define DT_PPC64_OPDSZ	(DT_LOPROC + 2)
-#define DT_PPC64_OPT	(DT_LOPROC + 3)
-#define DT_PPC64_NUM	4
-
-#define PPC64_OPT_TLS		1
-#define PPC64_OPT_MULTI_TOC	2
-
-#define STO_PPC64_LOCAL_BIT	5
-#define STO_PPC64_LOCAL_MASK	0xe0
-#define PPC64_LOCAL_ENTRY_OFFSET(x) (1 << (((x)&0xe0)>>5) & 0xfc)
-
-
-#define EF_ARM_RELEXEC		0x01
-#define EF_ARM_HASENTRY		0x02
-#define EF_ARM_INTERWORK	0x04
-#define EF_ARM_APCS_26		0x08
-#define EF_ARM_APCS_FLOAT	0x10
-#define EF_ARM_PIC		0x20
-#define EF_ARM_ALIGN8		0x40
-#define EF_ARM_NEW_ABI		0x80
-#define EF_ARM_OLD_ABI		0x100
-#define EF_ARM_SOFT_FLOAT	0x200
-#define EF_ARM_VFP_FLOAT	0x400
-#define EF_ARM_MAVERICK_FLOAT	0x800
-
-#define EF_ARM_ABI_FLOAT_SOFT	0x200
-#define EF_ARM_ABI_FLOAT_HARD	0x400
-
-
-#define EF_ARM_SYMSARESORTED	0x04
-#define EF_ARM_DYNSYMSUSESEGIDX	0x08
-#define EF_ARM_MAPSYMSFIRST	0x10
-#define EF_ARM_EABIMASK		0XFF000000
-
-
-#define EF_ARM_BE8	    0x00800000
-#define EF_ARM_LE8	    0x00400000
-
-#define EF_ARM_EABI_VERSION(flags)	((flags) & EF_ARM_EABIMASK)
-#define EF_ARM_EABI_UNKNOWN	0x00000000
-#define EF_ARM_EABI_VER1	0x01000000
-#define EF_ARM_EABI_VER2	0x02000000
-#define EF_ARM_EABI_VER3	0x03000000
-#define EF_ARM_EABI_VER4	0x04000000
-#define EF_ARM_EABI_VER5	0x05000000
-
-
-#define STT_ARM_TFUNC		STT_LOPROC
-#define STT_ARM_16BIT		STT_HIPROC
-
-
-#define SHF_ARM_ENTRYSECT	0x10000000
-#define SHF_ARM_COMDEF		0x80000000
-
-
-
-#define PF_ARM_SB		0x10000000
-
-#define PF_ARM_PI		0x20000000
-#define PF_ARM_ABS		0x40000000
-
-
-#define PT_ARM_EXIDX		(PT_LOPROC + 1)
-
-
-#define SHT_ARM_EXIDX		(SHT_LOPROC + 1)
-#define SHT_ARM_PREEMPTMAP	(SHT_LOPROC + 2)
-#define SHT_ARM_ATTRIBUTES	(SHT_LOPROC + 3)
-
-#define R_AARCH64_NONE            0
-#define R_AARCH64_P32_ABS32	1
-#define R_AARCH64_P32_COPY	180
-#define R_AARCH64_P32_GLOB_DAT	181
-#define R_AARCH64_P32_JUMP_SLOT	182
-#define R_AARCH64_P32_RELATIVE	183
+#define R_PPC64_TLSGD 107
+#define R_PPC64_TLSLD 108
+#define R_PPC64_TOCSAVE 109
+#define R_PPC64_ADDR16_HIGH 110
+#define R_PPC64_ADDR16_HIGHA 111
+#define R_PPC64_TPREL16_HIGH 112
+#define R_PPC64_TPREL16_HIGHA 113
+#define R_PPC64_DTPREL16_HIGH 114
+#define R_PPC64_DTPREL16_HIGHA 115
+
+#define R_PPC64_JMP_IREL 247
+#define R_PPC64_IRELATIVE 248
+#define R_PPC64_REL16 249
+#define R_PPC64_REL16_LO 250
+#define R_PPC64_REL16_HI 251
+#define R_PPC64_REL16_HA 252
+
+#define EF_PPC64_ABI 3
+
+#define DT_PPC64_GLINK (DT_LOPROC + 0)
+#define DT_PPC64_OPD (DT_LOPROC + 1)
+#define DT_PPC64_OPDSZ (DT_LOPROC + 2)
+#define DT_PPC64_OPT (DT_LOPROC + 3)
+#define DT_PPC64_NUM 4
+
+#define PPC64_OPT_TLS 1
+#define PPC64_OPT_MULTI_TOC 2
+
+#define STO_PPC64_LOCAL_BIT 5
+#define STO_PPC64_LOCAL_MASK 0xe0
+#define PPC64_LOCAL_ENTRY_OFFSET(x) (1 << (((x)&0xe0) >> 5) & 0xfc)
+
+#define EF_ARM_RELEXEC 0x01
+#define EF_ARM_HASENTRY 0x02
+#define EF_ARM_INTERWORK 0x04
+#define EF_ARM_APCS_26 0x08
+#define EF_ARM_APCS_FLOAT 0x10
+#define EF_ARM_PIC 0x20
+#define EF_ARM_ALIGN8 0x40
+#define EF_ARM_NEW_ABI 0x80
+#define EF_ARM_OLD_ABI 0x100
+#define EF_ARM_SOFT_FLOAT 0x200
+#define EF_ARM_VFP_FLOAT 0x400
+#define EF_ARM_MAVERICK_FLOAT 0x800
+
+#define EF_ARM_ABI_FLOAT_SOFT 0x200
+#define EF_ARM_ABI_FLOAT_HARD 0x400
+
+#define EF_ARM_SYMSARESORTED 0x04
+#define EF_ARM_DYNSYMSUSESEGIDX 0x08
+#define EF_ARM_MAPSYMSFIRST 0x10
+#define EF_ARM_EABIMASK 0XFF000000
+
+#define EF_ARM_BE8 0x00800000
+#define EF_ARM_LE8 0x00400000
+
+#define EF_ARM_EABI_VERSION(flags) ((flags)&EF_ARM_EABIMASK)
+#define EF_ARM_EABI_UNKNOWN 0x00000000
+#define EF_ARM_EABI_VER1 0x01000000
+#define EF_ARM_EABI_VER2 0x02000000
+#define EF_ARM_EABI_VER3 0x03000000
+#define EF_ARM_EABI_VER4 0x04000000
+#define EF_ARM_EABI_VER5 0x05000000
+
+#define STT_ARM_TFUNC STT_LOPROC
+#define STT_ARM_16BIT STT_HIPROC
+
+#define SHF_ARM_ENTRYSECT 0x10000000
+#define SHF_ARM_COMDEF 0x80000000
+
+#define PF_ARM_SB 0x10000000
+
+#define PF_ARM_PI 0x20000000
+#define PF_ARM_ABS 0x40000000
+
+#define PT_ARM_EXIDX (PT_LOPROC + 1)
+
+#define SHT_ARM_EXIDX (SHT_LOPROC + 1)
+#define SHT_ARM_PREEMPTMAP (SHT_LOPROC + 2)
+#define SHT_ARM_ATTRIBUTES (SHT_LOPROC + 3)
+
+#define R_AARCH64_NONE 0
+#define R_AARCH64_P32_ABS32 1
+#define R_AARCH64_P32_COPY 180
+#define R_AARCH64_P32_GLOB_DAT 181
+#define R_AARCH64_P32_JUMP_SLOT 182
+#define R_AARCH64_P32_RELATIVE 183
 #define R_AARCH64_P32_TLS_DTPMOD 184
 #define R_AARCH64_P32_TLS_DTPREL 185
-#define R_AARCH64_P32_TLS_TPREL	186
-#define R_AARCH64_P32_TLSDESC	187
-#define R_AARCH64_P32_IRELATIVE	188
-#define R_AARCH64_ABS64         257
-#define R_AARCH64_ABS32         258
-#define R_AARCH64_ABS16		259
-#define R_AARCH64_PREL64	260
-#define R_AARCH64_PREL32	261
-#define R_AARCH64_PREL16	262
-#define R_AARCH64_MOVW_UABS_G0	263
+#define R_AARCH64_P32_TLS_TPREL 186
+#define R_AARCH64_P32_TLSDESC 187
+#define R_AARCH64_P32_IRELATIVE 188
+#define R_AARCH64_ABS64 257
+#define R_AARCH64_ABS32 258
+#define R_AARCH64_ABS16 259
+#define R_AARCH64_PREL64 260
+#define R_AARCH64_PREL32 261
+#define R_AARCH64_PREL16 262
+#define R_AARCH64_MOVW_UABS_G0 263
 #define R_AARCH64_MOVW_UABS_G0_NC 264
-#define R_AARCH64_MOVW_UABS_G1	265
+#define R_AARCH64_MOVW_UABS_G1 265
 #define R_AARCH64_MOVW_UABS_G1_NC 266
-#define R_AARCH64_MOVW_UABS_G2	267
+#define R_AARCH64_MOVW_UABS_G2 267
 #define R_AARCH64_MOVW_UABS_G2_NC 268
-#define R_AARCH64_MOVW_UABS_G3	269
-#define R_AARCH64_MOVW_SABS_G0	270
-#define R_AARCH64_MOVW_SABS_G1	271
-#define R_AARCH64_MOVW_SABS_G2	272
-#define R_AARCH64_LD_PREL_LO19	273
-#define R_AARCH64_ADR_PREL_LO21	274
+#define R_AARCH64_MOVW_UABS_G3 269
+#define R_AARCH64_MOVW_SABS_G0 270
+#define R_AARCH64_MOVW_SABS_G1 271
+#define R_AARCH64_MOVW_SABS_G2 272
+#define R_AARCH64_LD_PREL_LO19 273
+#define R_AARCH64_ADR_PREL_LO21 274
 #define R_AARCH64_ADR_PREL_PG_HI21 275
 #define R_AARCH64_ADR_PREL_PG_HI21_NC 276
 #define R_AARCH64_ADD_ABS_LO12_NC 277
 #define R_AARCH64_LDST8_ABS_LO12_NC 278
-#define R_AARCH64_TSTBR14	279
-#define R_AARCH64_CONDBR19	280
-#define R_AARCH64_JUMP26	282
-#define R_AARCH64_CALL26	283
+#define R_AARCH64_TSTBR14 279
+#define R_AARCH64_CONDBR19 280
+#define R_AARCH64_JUMP26 282
+#define R_AARCH64_CALL26 283
 #define R_AARCH64_LDST16_ABS_LO12_NC 284
 #define R_AARCH64_LDST32_ABS_LO12_NC 285
 #define R_AARCH64_LDST64_ABS_LO12_NC 286
-#define R_AARCH64_MOVW_PREL_G0	287
+#define R_AARCH64_MOVW_PREL_G0 287
 #define R_AARCH64_MOVW_PREL_G0_NC 288
-#define R_AARCH64_MOVW_PREL_G1	289
+#define R_AARCH64_MOVW_PREL_G1 289
 #define R_AARCH64_MOVW_PREL_G1_NC 290
-#define R_AARCH64_MOVW_PREL_G2	291
+#define R_AARCH64_MOVW_PREL_G2 291
 #define R_AARCH64_MOVW_PREL_G2_NC 292
-#define R_AARCH64_MOVW_PREL_G3	293
+#define R_AARCH64_MOVW_PREL_G3 293
 #define R_AARCH64_LDST128_ABS_LO12_NC 299
 #define R_AARCH64_MOVW_GOTOFF_G0 300
 #define R_AARCH64_MOVW_GOTOFF_G0_NC 301
@@ -2377,22 +2166,22 @@ enum
 #define R_AARCH64_MOVW_GOTOFF_G2 304
 #define R_AARCH64_MOVW_GOTOFF_G2_NC 305
 #define R_AARCH64_MOVW_GOTOFF_G3 306
-#define R_AARCH64_GOTREL64	307
-#define R_AARCH64_GOTREL32	308
-#define R_AARCH64_GOT_LD_PREL19	309
+#define R_AARCH64_GOTREL64 307
+#define R_AARCH64_GOTREL32 308
+#define R_AARCH64_GOT_LD_PREL19 309
 #define R_AARCH64_LD64_GOTOFF_LO15 310
-#define R_AARCH64_ADR_GOT_PAGE	311
+#define R_AARCH64_ADR_GOT_PAGE 311
 #define R_AARCH64_LD64_GOT_LO12_NC 312
 #define R_AARCH64_LD64_GOTPAGE_LO15 313
 #define R_AARCH64_TLSGD_ADR_PREL21 512
 #define R_AARCH64_TLSGD_ADR_PAGE21 513
 #define R_AARCH64_TLSGD_ADD_LO12_NC 514
-#define R_AARCH64_TLSGD_MOVW_G1	515
+#define R_AARCH64_TLSGD_MOVW_G1 515
 #define R_AARCH64_TLSGD_MOVW_G0_NC 516
 #define R_AARCH64_TLSLD_ADR_PREL21 517
 #define R_AARCH64_TLSLD_ADR_PAGE21 518
 #define R_AARCH64_TLSLD_ADD_LO12_NC 519
-#define R_AARCH64_TLSLD_MOVW_G1	520
+#define R_AARCH64_TLSLD_MOVW_G1 520
 #define R_AARCH64_TLSLD_MOVW_G0_NC 521
 #define R_AARCH64_TLSLD_LD_PREL19 522
 #define R_AARCH64_TLSLD_MOVW_DTPREL_G2 523
@@ -2439,586 +2228,564 @@ enum
 #define R_AARCH64_TLSDESC_ADD_LO12 564
 #define R_AARCH64_TLSDESC_OFF_G1 565
 #define R_AARCH64_TLSDESC_OFF_G0_NC 566
-#define R_AARCH64_TLSDESC_LDR	567
-#define R_AARCH64_TLSDESC_ADD	568
-#define R_AARCH64_TLSDESC_CALL	569
+#define R_AARCH64_TLSDESC_LDR 567
+#define R_AARCH64_TLSDESC_ADD 568
+#define R_AARCH64_TLSDESC_CALL 569
 #define R_AARCH64_TLSLE_LDST128_TPREL_LO12 570
 #define R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC 571
 #define R_AARCH64_TLSLD_LDST128_DTPREL_LO12 572
 #define R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC 573
-#define R_AARCH64_COPY         1024
-#define R_AARCH64_GLOB_DAT     1025
-#define R_AARCH64_JUMP_SLOT    1026
-#define R_AARCH64_RELATIVE     1027
-#define R_AARCH64_TLS_DTPMOD   1028
+#define R_AARCH64_COPY 1024
+#define R_AARCH64_GLOB_DAT 1025
+#define R_AARCH64_JUMP_SLOT 1026
+#define R_AARCH64_RELATIVE 1027
+#define R_AARCH64_TLS_DTPMOD 1028
 #define R_AARCH64_TLS_DTPMOD64 1028
-#define R_AARCH64_TLS_DTPREL   1029
+#define R_AARCH64_TLS_DTPREL 1029
 #define R_AARCH64_TLS_DTPREL64 1029
-#define R_AARCH64_TLS_TPREL    1030
-#define R_AARCH64_TLS_TPREL64  1030
-#define R_AARCH64_TLSDESC      1031
-
-
-#define R_ARM_NONE		0
-#define R_ARM_PC24		1
-#define R_ARM_ABS32		2
-#define R_ARM_REL32		3
-#define R_ARM_PC13		4
-#define R_ARM_ABS16		5
-#define R_ARM_ABS12		6
-#define R_ARM_THM_ABS5		7
-#define R_ARM_ABS8		8
-#define R_ARM_SBREL32		9
-#define R_ARM_THM_PC22		10
-#define R_ARM_THM_PC8		11
-#define R_ARM_AMP_VCALL9	12
-#define R_ARM_TLS_DESC		13
-#define R_ARM_THM_SWI8		14
-#define R_ARM_XPC25		15
-#define R_ARM_THM_XPC22		16
-#define R_ARM_TLS_DTPMOD32	17
-#define R_ARM_TLS_DTPOFF32	18
-#define R_ARM_TLS_TPOFF32	19
-#define R_ARM_COPY		20
-#define R_ARM_GLOB_DAT		21
-#define R_ARM_JUMP_SLOT		22
-#define R_ARM_RELATIVE		23
-#define R_ARM_GOTOFF		24
-#define R_ARM_GOTPC		25
-#define R_ARM_GOT32		26
-#define R_ARM_PLT32		27
-#define R_ARM_CALL		28
-#define R_ARM_JUMP24		29
-#define R_ARM_THM_JUMP24	30
-#define R_ARM_BASE_ABS		31
-#define R_ARM_ALU_PCREL_7_0	32
-#define R_ARM_ALU_PCREL_15_8	33
-#define R_ARM_ALU_PCREL_23_15	34
-#define R_ARM_LDR_SBREL_11_0	35
-#define R_ARM_ALU_SBREL_19_12	36
-#define R_ARM_ALU_SBREL_27_20	37
-#define R_ARM_TARGET1		38
-#define R_ARM_SBREL31		39
-#define R_ARM_V4BX		40
-#define R_ARM_TARGET2		41
-#define R_ARM_PREL31		42
-#define R_ARM_MOVW_ABS_NC	43
-#define R_ARM_MOVT_ABS		44
-#define R_ARM_MOVW_PREL_NC	45
-#define R_ARM_MOVT_PREL		46
-#define R_ARM_THM_MOVW_ABS_NC	47
-#define R_ARM_THM_MOVT_ABS	48
-#define R_ARM_THM_MOVW_PREL_NC	49
-#define R_ARM_THM_MOVT_PREL	50
-#define R_ARM_THM_JUMP19	51
-#define R_ARM_THM_JUMP6		52
-#define R_ARM_THM_ALU_PREL_11_0	53
-#define R_ARM_THM_PC12		54
-#define R_ARM_ABS32_NOI		55
-#define R_ARM_REL32_NOI		56
-#define R_ARM_ALU_PC_G0_NC	57
-#define R_ARM_ALU_PC_G0		58
-#define R_ARM_ALU_PC_G1_NC	59
-#define R_ARM_ALU_PC_G1		60
-#define R_ARM_ALU_PC_G2		61
-#define R_ARM_LDR_PC_G1		62
-#define R_ARM_LDR_PC_G2		63
-#define R_ARM_LDRS_PC_G0	64
-#define R_ARM_LDRS_PC_G1	65
-#define R_ARM_LDRS_PC_G2	66
-#define R_ARM_LDC_PC_G0		67
-#define R_ARM_LDC_PC_G1		68
-#define R_ARM_LDC_PC_G2		69
-#define R_ARM_ALU_SB_G0_NC	70
-#define R_ARM_ALU_SB_G0		71
-#define R_ARM_ALU_SB_G1_NC	72
-#define R_ARM_ALU_SB_G1		73
-#define R_ARM_ALU_SB_G2		74
-#define R_ARM_LDR_SB_G0		75
-#define R_ARM_LDR_SB_G1		76
-#define R_ARM_LDR_SB_G2		77
-#define R_ARM_LDRS_SB_G0	78
-#define R_ARM_LDRS_SB_G1	79
-#define R_ARM_LDRS_SB_G2	80
-#define R_ARM_LDC_SB_G0		81
-#define R_ARM_LDC_SB_G1		82
-#define R_ARM_LDC_SB_G2		83
-#define R_ARM_MOVW_BREL_NC	84
-#define R_ARM_MOVT_BREL		85
-#define R_ARM_MOVW_BREL		86
-#define R_ARM_THM_MOVW_BREL_NC	87
-#define R_ARM_THM_MOVT_BREL	88
-#define R_ARM_THM_MOVW_BREL	89
-#define R_ARM_TLS_GOTDESC	90
-#define R_ARM_TLS_CALL		91
-#define R_ARM_TLS_DESCSEQ	92
-#define R_ARM_THM_TLS_CALL	93
-#define R_ARM_PLT32_ABS		94
-#define R_ARM_GOT_ABS		95
-#define R_ARM_GOT_PREL		96
-#define R_ARM_GOT_BREL12	97
-#define R_ARM_GOTOFF12		98
-#define R_ARM_GOTRELAX		99
-#define R_ARM_GNU_VTENTRY	100
-#define R_ARM_GNU_VTINHERIT	101
-#define R_ARM_THM_PC11		102
-#define R_ARM_THM_PC9		103
-#define R_ARM_TLS_GD32		104
-
-#define R_ARM_TLS_LDM32		105
-
-#define R_ARM_TLS_LDO32		106
-
-#define R_ARM_TLS_IE32		107
-
-#define R_ARM_TLS_LE32		108
-#define R_ARM_TLS_LDO12		109
-#define R_ARM_TLS_LE12		110
-#define R_ARM_TLS_IE12GP	111
-#define R_ARM_ME_TOO		128
-#define R_ARM_THM_TLS_DESCSEQ	129
-#define R_ARM_THM_TLS_DESCSEQ16	129
-#define R_ARM_THM_TLS_DESCSEQ32	130
-#define R_ARM_THM_GOT_BREL12	131
-#define R_ARM_IRELATIVE		160
-#define R_ARM_RXPC25		249
-#define R_ARM_RSBREL32		250
-#define R_ARM_THM_RPC22		251
-#define R_ARM_RREL32		252
-#define R_ARM_RABS22		253
-#define R_ARM_RPC24		254
-#define R_ARM_RBASE		255
-
-#define R_ARM_NUM		256
-
-
-
-
-#define EF_IA_64_MASKOS		0x0000000f
-#define EF_IA_64_ABI64		0x00000010
-#define EF_IA_64_ARCH		0xff000000
-
-
-#define PT_IA_64_ARCHEXT	(PT_LOPROC + 0)
-#define PT_IA_64_UNWIND		(PT_LOPROC + 1)
-#define PT_IA_64_HP_OPT_ANOT	(PT_LOOS + 0x12)
-#define PT_IA_64_HP_HSL_ANOT	(PT_LOOS + 0x13)
-#define PT_IA_64_HP_STACK	(PT_LOOS + 0x14)
-
-
-#define PF_IA_64_NORECOV	0x80000000
-
-
-#define SHT_IA_64_EXT		(SHT_LOPROC + 0)
-#define SHT_IA_64_UNWIND	(SHT_LOPROC + 1)
-
-
-#define SHF_IA_64_SHORT		0x10000000
-#define SHF_IA_64_NORECOV	0x20000000
-
-
-#define DT_IA_64_PLT_RESERVE	(DT_LOPROC + 0)
-#define DT_IA_64_NUM		1
-
-
-#define R_IA64_NONE		0x00
-#define R_IA64_IMM14		0x21
-#define R_IA64_IMM22		0x22
-#define R_IA64_IMM64		0x23
-#define R_IA64_DIR32MSB		0x24
-#define R_IA64_DIR32LSB		0x25
-#define R_IA64_DIR64MSB		0x26
-#define R_IA64_DIR64LSB		0x27
-#define R_IA64_GPREL22		0x2a
-#define R_IA64_GPREL64I		0x2b
-#define R_IA64_GPREL32MSB	0x2c
-#define R_IA64_GPREL32LSB	0x2d
-#define R_IA64_GPREL64MSB	0x2e
-#define R_IA64_GPREL64LSB	0x2f
-#define R_IA64_LTOFF22		0x32
-#define R_IA64_LTOFF64I		0x33
-#define R_IA64_PLTOFF22		0x3a
-#define R_IA64_PLTOFF64I	0x3b
-#define R_IA64_PLTOFF64MSB	0x3e
-#define R_IA64_PLTOFF64LSB	0x3f
-#define R_IA64_FPTR64I		0x43
-#define R_IA64_FPTR32MSB	0x44
-#define R_IA64_FPTR32LSB	0x45
-#define R_IA64_FPTR64MSB	0x46
-#define R_IA64_FPTR64LSB	0x47
-#define R_IA64_PCREL60B		0x48
-#define R_IA64_PCREL21B		0x49
-#define R_IA64_PCREL21M		0x4a
-#define R_IA64_PCREL21F		0x4b
-#define R_IA64_PCREL32MSB	0x4c
-#define R_IA64_PCREL32LSB	0x4d
-#define R_IA64_PCREL64MSB	0x4e
-#define R_IA64_PCREL64LSB	0x4f
-#define R_IA64_LTOFF_FPTR22	0x52
-#define R_IA64_LTOFF_FPTR64I	0x53
-#define R_IA64_LTOFF_FPTR32MSB	0x54
-#define R_IA64_LTOFF_FPTR32LSB	0x55
-#define R_IA64_LTOFF_FPTR64MSB	0x56
-#define R_IA64_LTOFF_FPTR64LSB	0x57
-#define R_IA64_SEGREL32MSB	0x5c
-#define R_IA64_SEGREL32LSB	0x5d
-#define R_IA64_SEGREL64MSB	0x5e
-#define R_IA64_SEGREL64LSB	0x5f
-#define R_IA64_SECREL32MSB	0x64
-#define R_IA64_SECREL32LSB	0x65
-#define R_IA64_SECREL64MSB	0x66
-#define R_IA64_SECREL64LSB	0x67
-#define R_IA64_REL32MSB		0x6c
-#define R_IA64_REL32LSB		0x6d
-#define R_IA64_REL64MSB		0x6e
-#define R_IA64_REL64LSB		0x6f
-#define R_IA64_LTV32MSB		0x74
-#define R_IA64_LTV32LSB		0x75
-#define R_IA64_LTV64MSB		0x76
-#define R_IA64_LTV64LSB		0x77
-#define R_IA64_PCREL21BI	0x79
-#define R_IA64_PCREL22		0x7a
-#define R_IA64_PCREL64I		0x7b
-#define R_IA64_IPLTMSB		0x80
-#define R_IA64_IPLTLSB		0x81
-#define R_IA64_COPY		0x84
-#define R_IA64_SUB		0x85
-#define R_IA64_LTOFF22X		0x86
-#define R_IA64_LDXMOV		0x87
-#define R_IA64_TPREL14		0x91
-#define R_IA64_TPREL22		0x92
-#define R_IA64_TPREL64I		0x93
-#define R_IA64_TPREL64MSB	0x96
-#define R_IA64_TPREL64LSB	0x97
-#define R_IA64_LTOFF_TPREL22	0x9a
-#define R_IA64_DTPMOD64MSB	0xa6
-#define R_IA64_DTPMOD64LSB	0xa7
-#define R_IA64_LTOFF_DTPMOD22	0xaa
-#define R_IA64_DTPREL14		0xb1
-#define R_IA64_DTPREL22		0xb2
-#define R_IA64_DTPREL64I	0xb3
-#define R_IA64_DTPREL32MSB	0xb4
-#define R_IA64_DTPREL32LSB	0xb5
-#define R_IA64_DTPREL64MSB	0xb6
-#define R_IA64_DTPREL64LSB	0xb7
-#define R_IA64_LTOFF_DTPREL22	0xba
-
-
-#define EF_SH_MACH_MASK		0x1f
-#define EF_SH_UNKNOWN		0x0
-#define EF_SH1			0x1
-#define EF_SH2			0x2
-#define EF_SH3			0x3
-#define EF_SH_DSP		0x4
-#define EF_SH3_DSP		0x5
-#define EF_SH4AL_DSP		0x6
-#define EF_SH3E			0x8
-#define EF_SH4			0x9
-#define EF_SH2E			0xb
-#define EF_SH4A			0xc
-#define EF_SH2A			0xd
-#define EF_SH4_NOFPU		0x10
-#define EF_SH4A_NOFPU		0x11
-#define EF_SH4_NOMMU_NOFPU	0x12
-#define EF_SH2A_NOFPU		0x13
-#define EF_SH3_NOMMU		0x14
-#define EF_SH2A_SH4_NOFPU	0x15
-#define EF_SH2A_SH3_NOFPU	0x16
-#define EF_SH2A_SH4		0x17
-#define EF_SH2A_SH3E		0x18
-
-#define	R_SH_NONE		0
-#define	R_SH_DIR32		1
-#define	R_SH_REL32		2
-#define	R_SH_DIR8WPN		3
-#define	R_SH_IND12W		4
-#define	R_SH_DIR8WPL		5
-#define	R_SH_DIR8WPZ		6
-#define	R_SH_DIR8BP		7
-#define	R_SH_DIR8W		8
-#define	R_SH_DIR8L		9
-#define	R_SH_SWITCH16		25
-#define	R_SH_SWITCH32		26
-#define	R_SH_USES		27
-#define	R_SH_COUNT		28
-#define	R_SH_ALIGN		29
-#define	R_SH_CODE		30
-#define	R_SH_DATA		31
-#define	R_SH_LABEL		32
-#define	R_SH_SWITCH8		33
-#define	R_SH_GNU_VTINHERIT	34
-#define	R_SH_GNU_VTENTRY	35
-#define	R_SH_TLS_GD_32		144
-#define	R_SH_TLS_LD_32		145
-#define	R_SH_TLS_LDO_32		146
-#define	R_SH_TLS_IE_32		147
-#define	R_SH_TLS_LE_32		148
-#define	R_SH_TLS_DTPMOD32	149
-#define	R_SH_TLS_DTPOFF32	150
-#define	R_SH_TLS_TPOFF32	151
-#define	R_SH_GOT32		160
-#define	R_SH_PLT32		161
-#define	R_SH_COPY		162
-#define	R_SH_GLOB_DAT		163
-#define	R_SH_JMP_SLOT		164
-#define	R_SH_RELATIVE		165
-#define	R_SH_GOTOFF		166
-#define	R_SH_GOTPC		167
-#define	R_SH_GOT20		201
-#define	R_SH_GOTOFF20		202
-#define	R_SH_GOTFUNCDESC	203
-#define	R_SH_GOTFUNCDEST20	204
-#define	R_SH_GOTOFFFUNCDESC	205
-#define	R_SH_GOTOFFFUNCDEST20	206
-#define	R_SH_FUNCDESC		207
-#define	R_SH_FUNCDESC_VALUE	208
-
-#define	R_SH_NUM		256
-
-
-
-#define R_390_NONE		0
-#define R_390_8			1
-#define R_390_12		2
-#define R_390_16		3
-#define R_390_32		4
-#define R_390_PC32		5
-#define R_390_GOT12		6
-#define R_390_GOT32		7
-#define R_390_PLT32		8
-#define R_390_COPY		9
-#define R_390_GLOB_DAT		10
-#define R_390_JMP_SLOT		11
-#define R_390_RELATIVE		12
-#define R_390_GOTOFF32		13
-#define R_390_GOTPC		14
-#define R_390_GOT16		15
-#define R_390_PC16		16
-#define R_390_PC16DBL		17
-#define R_390_PLT16DBL		18
-#define R_390_PC32DBL		19
-#define R_390_PLT32DBL		20
-#define R_390_GOTPCDBL		21
-#define R_390_64		22
-#define R_390_PC64		23
-#define R_390_GOT64		24
-#define R_390_PLT64		25
-#define R_390_GOTENT		26
-#define R_390_GOTOFF16		27
-#define R_390_GOTOFF64		28
-#define R_390_GOTPLT12		29
-#define R_390_GOTPLT16		30
-#define R_390_GOTPLT32		31
-#define R_390_GOTPLT64		32
-#define R_390_GOTPLTENT		33
-#define R_390_PLTOFF16		34
-#define R_390_PLTOFF32		35
-#define R_390_PLTOFF64		36
-#define R_390_TLS_LOAD		37
-#define R_390_TLS_GDCALL	38
-
-#define R_390_TLS_LDCALL	39
-
-#define R_390_TLS_GD32		40
-
-#define R_390_TLS_GD64		41
-
-#define R_390_TLS_GOTIE12	42
-
-#define R_390_TLS_GOTIE32	43
-
-#define R_390_TLS_GOTIE64	44
-
-#define R_390_TLS_LDM32		45
-
-#define R_390_TLS_LDM64		46
-
-#define R_390_TLS_IE32		47
-
-#define R_390_TLS_IE64		48
-
-#define R_390_TLS_IEENT		49
-
-#define R_390_TLS_LE32		50
-
-#define R_390_TLS_LE64		51
-
-#define R_390_TLS_LDO32		52
-
-#define R_390_TLS_LDO64		53
-
-#define R_390_TLS_DTPMOD	54
-#define R_390_TLS_DTPOFF	55
-#define R_390_TLS_TPOFF		56
-
-#define R_390_20		57
-#define R_390_GOT20		58
-#define R_390_GOTPLT20		59
-#define R_390_TLS_GOTIE20	60
-
-
-#define R_390_NUM		61
-
-
-
-#define R_CRIS_NONE		0
-#define R_CRIS_8		1
-#define R_CRIS_16		2
-#define R_CRIS_32		3
-#define R_CRIS_8_PCREL		4
-#define R_CRIS_16_PCREL		5
-#define R_CRIS_32_PCREL		6
-#define R_CRIS_GNU_VTINHERIT	7
-#define R_CRIS_GNU_VTENTRY	8
-#define R_CRIS_COPY		9
-#define R_CRIS_GLOB_DAT		10
-#define R_CRIS_JUMP_SLOT	11
-#define R_CRIS_RELATIVE		12
-#define R_CRIS_16_GOT		13
-#define R_CRIS_32_GOT		14
-#define R_CRIS_16_GOTPLT	15
-#define R_CRIS_32_GOTPLT	16
-#define R_CRIS_32_GOTREL	17
-#define R_CRIS_32_PLT_GOTREL	18
-#define R_CRIS_32_PLT_PCREL	19
-
-#define R_CRIS_NUM		20
-
-
-
-#define R_X86_64_NONE		0
-#define R_X86_64_64		1
-#define R_X86_64_PC32		2
-#define R_X86_64_GOT32		3
-#define R_X86_64_PLT32		4
-#define R_X86_64_COPY		5
-#define R_X86_64_GLOB_DAT	6
-#define R_X86_64_JUMP_SLOT	7
-#define R_X86_64_RELATIVE	8
-#define R_X86_64_GOTPCREL	9
-
-#define R_X86_64_32		10
-#define R_X86_64_32S		11
-#define R_X86_64_16		12
-#define R_X86_64_PC16		13
-#define R_X86_64_8		14
-#define R_X86_64_PC8		15
-#define R_X86_64_DTPMOD64	16
-#define R_X86_64_DTPOFF64	17
-#define R_X86_64_TPOFF64	18
-#define R_X86_64_TLSGD		19
-
-#define R_X86_64_TLSLD		20
-
-#define R_X86_64_DTPOFF32	21
-#define R_X86_64_GOTTPOFF	22
-
-#define R_X86_64_TPOFF32	23
-#define R_X86_64_PC64		24
-#define R_X86_64_GOTOFF64	25
-#define R_X86_64_GOTPC32	26
-#define R_X86_64_GOT64		27
-#define R_X86_64_GOTPCREL64	28
-#define R_X86_64_GOTPC64	29
-#define R_X86_64_GOTPLT64	30
-#define R_X86_64_PLTOFF64	31
-#define R_X86_64_SIZE32		32
-#define R_X86_64_SIZE64		33
+#define R_AARCH64_TLS_TPREL 1030
+#define R_AARCH64_TLS_TPREL64 1030
+#define R_AARCH64_TLSDESC 1031
+
+#define R_ARM_NONE 0
+#define R_ARM_PC24 1
+#define R_ARM_ABS32 2
+#define R_ARM_REL32 3
+#define R_ARM_PC13 4
+#define R_ARM_ABS16 5
+#define R_ARM_ABS12 6
+#define R_ARM_THM_ABS5 7
+#define R_ARM_ABS8 8
+#define R_ARM_SBREL32 9
+#define R_ARM_THM_PC22 10
+#define R_ARM_THM_PC8 11
+#define R_ARM_AMP_VCALL9 12
+#define R_ARM_TLS_DESC 13
+#define R_ARM_THM_SWI8 14
+#define R_ARM_XPC25 15
+#define R_ARM_THM_XPC22 16
+#define R_ARM_TLS_DTPMOD32 17
+#define R_ARM_TLS_DTPOFF32 18
+#define R_ARM_TLS_TPOFF32 19
+#define R_ARM_COPY 20
+#define R_ARM_GLOB_DAT 21
+#define R_ARM_JUMP_SLOT 22
+#define R_ARM_RELATIVE 23
+#define R_ARM_GOTOFF 24
+#define R_ARM_GOTPC 25
+#define R_ARM_GOT32 26
+#define R_ARM_PLT32 27
+#define R_ARM_CALL 28
+#define R_ARM_JUMP24 29
+#define R_ARM_THM_JUMP24 30
+#define R_ARM_BASE_ABS 31
+#define R_ARM_ALU_PCREL_7_0 32
+#define R_ARM_ALU_PCREL_15_8 33
+#define R_ARM_ALU_PCREL_23_15 34
+#define R_ARM_LDR_SBREL_11_0 35
+#define R_ARM_ALU_SBREL_19_12 36
+#define R_ARM_ALU_SBREL_27_20 37
+#define R_ARM_TARGET1 38
+#define R_ARM_SBREL31 39
+#define R_ARM_V4BX 40
+#define R_ARM_TARGET2 41
+#define R_ARM_PREL31 42
+#define R_ARM_MOVW_ABS_NC 43
+#define R_ARM_MOVT_ABS 44
+#define R_ARM_MOVW_PREL_NC 45
+#define R_ARM_MOVT_PREL 46
+#define R_ARM_THM_MOVW_ABS_NC 47
+#define R_ARM_THM_MOVT_ABS 48
+#define R_ARM_THM_MOVW_PREL_NC 49
+#define R_ARM_THM_MOVT_PREL 50
+#define R_ARM_THM_JUMP19 51
+#define R_ARM_THM_JUMP6 52
+#define R_ARM_THM_ALU_PREL_11_0 53
+#define R_ARM_THM_PC12 54
+#define R_ARM_ABS32_NOI 55
+#define R_ARM_REL32_NOI 56
+#define R_ARM_ALU_PC_G0_NC 57
+#define R_ARM_ALU_PC_G0 58
+#define R_ARM_ALU_PC_G1_NC 59
+#define R_ARM_ALU_PC_G1 60
+#define R_ARM_ALU_PC_G2 61
+#define R_ARM_LDR_PC_G1 62
+#define R_ARM_LDR_PC_G2 63
+#define R_ARM_LDRS_PC_G0 64
+#define R_ARM_LDRS_PC_G1 65
+#define R_ARM_LDRS_PC_G2 66
+#define R_ARM_LDC_PC_G0 67
+#define R_ARM_LDC_PC_G1 68
+#define R_ARM_LDC_PC_G2 69
+#define R_ARM_ALU_SB_G0_NC 70
+#define R_ARM_ALU_SB_G0 71
+#define R_ARM_ALU_SB_G1_NC 72
+#define R_ARM_ALU_SB_G1 73
+#define R_ARM_ALU_SB_G2 74
+#define R_ARM_LDR_SB_G0 75
+#define R_ARM_LDR_SB_G1 76
+#define R_ARM_LDR_SB_G2 77
+#define R_ARM_LDRS_SB_G0 78
+#define R_ARM_LDRS_SB_G1 79
+#define R_ARM_LDRS_SB_G2 80
+#define R_ARM_LDC_SB_G0 81
+#define R_ARM_LDC_SB_G1 82
+#define R_ARM_LDC_SB_G2 83
+#define R_ARM_MOVW_BREL_NC 84
+#define R_ARM_MOVT_BREL 85
+#define R_ARM_MOVW_BREL 86
+#define R_ARM_THM_MOVW_BREL_NC 87
+#define R_ARM_THM_MOVT_BREL 88
+#define R_ARM_THM_MOVW_BREL 89
+#define R_ARM_TLS_GOTDESC 90
+#define R_ARM_TLS_CALL 91
+#define R_ARM_TLS_DESCSEQ 92
+#define R_ARM_THM_TLS_CALL 93
+#define R_ARM_PLT32_ABS 94
+#define R_ARM_GOT_ABS 95
+#define R_ARM_GOT_PREL 96
+#define R_ARM_GOT_BREL12 97
+#define R_ARM_GOTOFF12 98
+#define R_ARM_GOTRELAX 99
+#define R_ARM_GNU_VTENTRY 100
+#define R_ARM_GNU_VTINHERIT 101
+#define R_ARM_THM_PC11 102
+#define R_ARM_THM_PC9 103
+#define R_ARM_TLS_GD32 104
+
+#define R_ARM_TLS_LDM32 105
+
+#define R_ARM_TLS_LDO32 106
+
+#define R_ARM_TLS_IE32 107
+
+#define R_ARM_TLS_LE32 108
+#define R_ARM_TLS_LDO12 109
+#define R_ARM_TLS_LE12 110
+#define R_ARM_TLS_IE12GP 111
+#define R_ARM_ME_TOO 128
+#define R_ARM_THM_TLS_DESCSEQ 129
+#define R_ARM_THM_TLS_DESCSEQ16 129
+#define R_ARM_THM_TLS_DESCSEQ32 130
+#define R_ARM_THM_GOT_BREL12 131
+#define R_ARM_IRELATIVE 160
+#define R_ARM_RXPC25 249
+#define R_ARM_RSBREL32 250
+#define R_ARM_THM_RPC22 251
+#define R_ARM_RREL32 252
+#define R_ARM_RABS22 253
+#define R_ARM_RPC24 254
+#define R_ARM_RBASE 255
+
+#define R_ARM_NUM 256
+
+#define EF_IA_64_MASKOS 0x0000000f
+#define EF_IA_64_ABI64 0x00000010
+#define EF_IA_64_ARCH 0xff000000
+
+#define PT_IA_64_ARCHEXT (PT_LOPROC + 0)
+#define PT_IA_64_UNWIND (PT_LOPROC + 1)
+#define PT_IA_64_HP_OPT_ANOT (PT_LOOS + 0x12)
+#define PT_IA_64_HP_HSL_ANOT (PT_LOOS + 0x13)
+#define PT_IA_64_HP_STACK (PT_LOOS + 0x14)
+
+#define PF_IA_64_NORECOV 0x80000000
+
+#define SHT_IA_64_EXT (SHT_LOPROC + 0)
+#define SHT_IA_64_UNWIND (SHT_LOPROC + 1)
+
+#define SHF_IA_64_SHORT 0x10000000
+#define SHF_IA_64_NORECOV 0x20000000
+
+#define DT_IA_64_PLT_RESERVE (DT_LOPROC + 0)
+#define DT_IA_64_NUM 1
+
+#define R_IA64_NONE 0x00
+#define R_IA64_IMM14 0x21
+#define R_IA64_IMM22 0x22
+#define R_IA64_IMM64 0x23
+#define R_IA64_DIR32MSB 0x24
+#define R_IA64_DIR32LSB 0x25
+#define R_IA64_DIR64MSB 0x26
+#define R_IA64_DIR64LSB 0x27
+#define R_IA64_GPREL22 0x2a
+#define R_IA64_GPREL64I 0x2b
+#define R_IA64_GPREL32MSB 0x2c
+#define R_IA64_GPREL32LSB 0x2d
+#define R_IA64_GPREL64MSB 0x2e
+#define R_IA64_GPREL64LSB 0x2f
+#define R_IA64_LTOFF22 0x32
+#define R_IA64_LTOFF64I 0x33
+#define R_IA64_PLTOFF22 0x3a
+#define R_IA64_PLTOFF64I 0x3b
+#define R_IA64_PLTOFF64MSB 0x3e
+#define R_IA64_PLTOFF64LSB 0x3f
+#define R_IA64_FPTR64I 0x43
+#define R_IA64_FPTR32MSB 0x44
+#define R_IA64_FPTR32LSB 0x45
+#define R_IA64_FPTR64MSB 0x46
+#define R_IA64_FPTR64LSB 0x47
+#define R_IA64_PCREL60B 0x48
+#define R_IA64_PCREL21B 0x49
+#define R_IA64_PCREL21M 0x4a
+#define R_IA64_PCREL21F 0x4b
+#define R_IA64_PCREL32MSB 0x4c
+#define R_IA64_PCREL32LSB 0x4d
+#define R_IA64_PCREL64MSB 0x4e
+#define R_IA64_PCREL64LSB 0x4f
+#define R_IA64_LTOFF_FPTR22 0x52
+#define R_IA64_LTOFF_FPTR64I 0x53
+#define R_IA64_LTOFF_FPTR32MSB 0x54
+#define R_IA64_LTOFF_FPTR32LSB 0x55
+#define R_IA64_LTOFF_FPTR64MSB 0x56
+#define R_IA64_LTOFF_FPTR64LSB 0x57
+#define R_IA64_SEGREL32MSB 0x5c
+#define R_IA64_SEGREL32LSB 0x5d
+#define R_IA64_SEGREL64MSB 0x5e
+#define R_IA64_SEGREL64LSB 0x5f
+#define R_IA64_SECREL32MSB 0x64
+#define R_IA64_SECREL32LSB 0x65
+#define R_IA64_SECREL64MSB 0x66
+#define R_IA64_SECREL64LSB 0x67
+#define R_IA64_REL32MSB 0x6c
+#define R_IA64_REL32LSB 0x6d
+#define R_IA64_REL64MSB 0x6e
+#define R_IA64_REL64LSB 0x6f
+#define R_IA64_LTV32MSB 0x74
+#define R_IA64_LTV32LSB 0x75
+#define R_IA64_LTV64MSB 0x76
+#define R_IA64_LTV64LSB 0x77
+#define R_IA64_PCREL21BI 0x79
+#define R_IA64_PCREL22 0x7a
+#define R_IA64_PCREL64I 0x7b
+#define R_IA64_IPLTMSB 0x80
+#define R_IA64_IPLTLSB 0x81
+#define R_IA64_COPY 0x84
+#define R_IA64_SUB 0x85
+#define R_IA64_LTOFF22X 0x86
+#define R_IA64_LDXMOV 0x87
+#define R_IA64_TPREL14 0x91
+#define R_IA64_TPREL22 0x92
+#define R_IA64_TPREL64I 0x93
+#define R_IA64_TPREL64MSB 0x96
+#define R_IA64_TPREL64LSB 0x97
+#define R_IA64_LTOFF_TPREL22 0x9a
+#define R_IA64_DTPMOD64MSB 0xa6
+#define R_IA64_DTPMOD64LSB 0xa7
+#define R_IA64_LTOFF_DTPMOD22 0xaa
+#define R_IA64_DTPREL14 0xb1
+#define R_IA64_DTPREL22 0xb2
+#define R_IA64_DTPREL64I 0xb3
+#define R_IA64_DTPREL32MSB 0xb4
+#define R_IA64_DTPREL32LSB 0xb5
+#define R_IA64_DTPREL64MSB 0xb6
+#define R_IA64_DTPREL64LSB 0xb7
+#define R_IA64_LTOFF_DTPREL22 0xba
+
+#define EF_SH_MACH_MASK 0x1f
+#define EF_SH_UNKNOWN 0x0
+#define EF_SH1 0x1
+#define EF_SH2 0x2
+#define EF_SH3 0x3
+#define EF_SH_DSP 0x4
+#define EF_SH3_DSP 0x5
+#define EF_SH4AL_DSP 0x6
+#define EF_SH3E 0x8
+#define EF_SH4 0x9
+#define EF_SH2E 0xb
+#define EF_SH4A 0xc
+#define EF_SH2A 0xd
+#define EF_SH4_NOFPU 0x10
+#define EF_SH4A_NOFPU 0x11
+#define EF_SH4_NOMMU_NOFPU 0x12
+#define EF_SH2A_NOFPU 0x13
+#define EF_SH3_NOMMU 0x14
+#define EF_SH2A_SH4_NOFPU 0x15
+#define EF_SH2A_SH3_NOFPU 0x16
+#define EF_SH2A_SH4 0x17
+#define EF_SH2A_SH3E 0x18
+
+#define R_SH_NONE 0
+#define R_SH_DIR32 1
+#define R_SH_REL32 2
+#define R_SH_DIR8WPN 3
+#define R_SH_IND12W 4
+#define R_SH_DIR8WPL 5
+#define R_SH_DIR8WPZ 6
+#define R_SH_DIR8BP 7
+#define R_SH_DIR8W 8
+#define R_SH_DIR8L 9
+#define R_SH_SWITCH16 25
+#define R_SH_SWITCH32 26
+#define R_SH_USES 27
+#define R_SH_COUNT 28
+#define R_SH_ALIGN 29
+#define R_SH_CODE 30
+#define R_SH_DATA 31
+#define R_SH_LABEL 32
+#define R_SH_SWITCH8 33
+#define R_SH_GNU_VTINHERIT 34
+#define R_SH_GNU_VTENTRY 35
+#define R_SH_TLS_GD_32 144
+#define R_SH_TLS_LD_32 145
+#define R_SH_TLS_LDO_32 146
+#define R_SH_TLS_IE_32 147
+#define R_SH_TLS_LE_32 148
+#define R_SH_TLS_DTPMOD32 149
+#define R_SH_TLS_DTPOFF32 150
+#define R_SH_TLS_TPOFF32 151
+#define R_SH_GOT32 160
+#define R_SH_PLT32 161
+#define R_SH_COPY 162
+#define R_SH_GLOB_DAT 163
+#define R_SH_JMP_SLOT 164
+#define R_SH_RELATIVE 165
+#define R_SH_GOTOFF 166
+#define R_SH_GOTPC 167
+#define R_SH_GOT20 201
+#define R_SH_GOTOFF20 202
+#define R_SH_GOTFUNCDESC 203
+#define R_SH_GOTFUNCDEST20 204
+#define R_SH_GOTOFFFUNCDESC 205
+#define R_SH_GOTOFFFUNCDEST20 206
+#define R_SH_FUNCDESC 207
+#define R_SH_FUNCDESC_VALUE 208
+
+#define R_SH_NUM 256
+
+#define R_390_NONE 0
+#define R_390_8 1
+#define R_390_12 2
+#define R_390_16 3
+#define R_390_32 4
+#define R_390_PC32 5
+#define R_390_GOT12 6
+#define R_390_GOT32 7
+#define R_390_PLT32 8
+#define R_390_COPY 9
+#define R_390_GLOB_DAT 10
+#define R_390_JMP_SLOT 11
+#define R_390_RELATIVE 12
+#define R_390_GOTOFF32 13
+#define R_390_GOTPC 14
+#define R_390_GOT16 15
+#define R_390_PC16 16
+#define R_390_PC16DBL 17
+#define R_390_PLT16DBL 18
+#define R_390_PC32DBL 19
+#define R_390_PLT32DBL 20
+#define R_390_GOTPCDBL 21
+#define R_390_64 22
+#define R_390_PC64 23
+#define R_390_GOT64 24
+#define R_390_PLT64 25
+#define R_390_GOTENT 26
+#define R_390_GOTOFF16 27
+#define R_390_GOTOFF64 28
+#define R_390_GOTPLT12 29
+#define R_390_GOTPLT16 30
+#define R_390_GOTPLT32 31
+#define R_390_GOTPLT64 32
+#define R_390_GOTPLTENT 33
+#define R_390_PLTOFF16 34
+#define R_390_PLTOFF32 35
+#define R_390_PLTOFF64 36
+#define R_390_TLS_LOAD 37
+#define R_390_TLS_GDCALL 38
+
+#define R_390_TLS_LDCALL 39
+
+#define R_390_TLS_GD32 40
+
+#define R_390_TLS_GD64 41
+
+#define R_390_TLS_GOTIE12 42
+
+#define R_390_TLS_GOTIE32 43
+
+#define R_390_TLS_GOTIE64 44
+
+#define R_390_TLS_LDM32 45
+
+#define R_390_TLS_LDM64 46
+
+#define R_390_TLS_IE32 47
+
+#define R_390_TLS_IE64 48
+
+#define R_390_TLS_IEENT 49
+
+#define R_390_TLS_LE32 50
+
+#define R_390_TLS_LE64 51
+
+#define R_390_TLS_LDO32 52
+
+#define R_390_TLS_LDO64 53
+
+#define R_390_TLS_DTPMOD 54
+#define R_390_TLS_DTPOFF 55
+#define R_390_TLS_TPOFF 56
+
+#define R_390_20 57
+#define R_390_GOT20 58
+#define R_390_GOTPLT20 59
+#define R_390_TLS_GOTIE20 60
+
+#define R_390_NUM 61
+
+#define R_CRIS_NONE 0
+#define R_CRIS_8 1
+#define R_CRIS_16 2
+#define R_CRIS_32 3
+#define R_CRIS_8_PCREL 4
+#define R_CRIS_16_PCREL 5
+#define R_CRIS_32_PCREL 6
+#define R_CRIS_GNU_VTINHERIT 7
+#define R_CRIS_GNU_VTENTRY 8
+#define R_CRIS_COPY 9
+#define R_CRIS_GLOB_DAT 10
+#define R_CRIS_JUMP_SLOT 11
+#define R_CRIS_RELATIVE 12
+#define R_CRIS_16_GOT 13
+#define R_CRIS_32_GOT 14
+#define R_CRIS_16_GOTPLT 15
+#define R_CRIS_32_GOTPLT 16
+#define R_CRIS_32_GOTREL 17
+#define R_CRIS_32_PLT_GOTREL 18
+#define R_CRIS_32_PLT_PCREL 19
+
+#define R_CRIS_NUM 20
+
+#define R_X86_64_NONE 0
+#define R_X86_64_64 1
+#define R_X86_64_PC32 2
+#define R_X86_64_GOT32 3
+#define R_X86_64_PLT32 4
+#define R_X86_64_COPY 5
+#define R_X86_64_GLOB_DAT 6
+#define R_X86_64_JUMP_SLOT 7
+#define R_X86_64_RELATIVE 8
+#define R_X86_64_GOTPCREL 9
+
+#define R_X86_64_32 10
+#define R_X86_64_32S 11
+#define R_X86_64_16 12
+#define R_X86_64_PC16 13
+#define R_X86_64_8 14
+#define R_X86_64_PC8 15
+#define R_X86_64_DTPMOD64 16
+#define R_X86_64_DTPOFF64 17
+#define R_X86_64_TPOFF64 18
+#define R_X86_64_TLSGD 19
+
+#define R_X86_64_TLSLD 20
+
+#define R_X86_64_DTPOFF32 21
+#define R_X86_64_GOTTPOFF 22
+
+#define R_X86_64_TPOFF32 23
+#define R_X86_64_PC64 24
+#define R_X86_64_GOTOFF64 25
+#define R_X86_64_GOTPC32 26
+#define R_X86_64_GOT64 27
+#define R_X86_64_GOTPCREL64 28
+#define R_X86_64_GOTPC64 29
+#define R_X86_64_GOTPLT64 30
+#define R_X86_64_PLTOFF64 31
+#define R_X86_64_SIZE32 32
+#define R_X86_64_SIZE64 33
 
 #define R_X86_64_GOTPC32_TLSDESC 34
-#define R_X86_64_TLSDESC_CALL   35
-
-#define R_X86_64_TLSDESC        36
-#define R_X86_64_IRELATIVE	37
-#define R_X86_64_RELATIVE64	38
-#define R_X86_64_GOTPCRELX	41
-#define R_X86_64_REX_GOTPCRELX	42
-#define R_X86_64_NUM		43
-
-
-
-#define R_MN10300_NONE		0
-#define R_MN10300_32		1
-#define R_MN10300_16		2
-#define R_MN10300_8		3
-#define R_MN10300_PCREL32	4
-#define R_MN10300_PCREL16	5
-#define R_MN10300_PCREL8	6
-#define R_MN10300_GNU_VTINHERIT	7
-#define R_MN10300_GNU_VTENTRY	8
-#define R_MN10300_24		9
-#define R_MN10300_GOTPC32	10
-#define R_MN10300_GOTPC16	11
-#define R_MN10300_GOTOFF32	12
-#define R_MN10300_GOTOFF24	13
-#define R_MN10300_GOTOFF16	14
-#define R_MN10300_PLT32		15
-#define R_MN10300_PLT16		16
-#define R_MN10300_GOT32		17
-#define R_MN10300_GOT24		18
-#define R_MN10300_GOT16		19
-#define R_MN10300_COPY		20
-#define R_MN10300_GLOB_DAT	21
-#define R_MN10300_JMP_SLOT	22
-#define R_MN10300_RELATIVE	23
-
-#define R_MN10300_NUM		24
-
-
-
-#define R_M32R_NONE		0
-#define R_M32R_16		1
-#define R_M32R_32		2
-#define R_M32R_24		3
-#define R_M32R_10_PCREL		4
-#define R_M32R_18_PCREL		5
-#define R_M32R_26_PCREL		6
-#define R_M32R_HI16_ULO		7
-#define R_M32R_HI16_SLO		8
-#define R_M32R_LO16		9
-#define R_M32R_SDA16		10
-#define R_M32R_GNU_VTINHERIT	11
-#define R_M32R_GNU_VTENTRY	12
-
-#define R_M32R_16_RELA		33
-#define R_M32R_32_RELA		34
-#define R_M32R_24_RELA		35
-#define R_M32R_10_PCREL_RELA	36
-#define R_M32R_18_PCREL_RELA	37
-#define R_M32R_26_PCREL_RELA	38
-#define R_M32R_HI16_ULO_RELA	39
-#define R_M32R_HI16_SLO_RELA	40
-#define R_M32R_LO16_RELA	41
-#define R_M32R_SDA16_RELA	42
-#define R_M32R_RELA_GNU_VTINHERIT	43
-#define R_M32R_RELA_GNU_VTENTRY	44
-#define R_M32R_REL32		45
-
-#define R_M32R_GOT24		48
-#define R_M32R_26_PLTREL	49
-#define R_M32R_COPY		50
-#define R_M32R_GLOB_DAT		51
-#define R_M32R_JMP_SLOT		52
-#define R_M32R_RELATIVE		53
-#define R_M32R_GOTOFF		54
-#define R_M32R_GOTPC24		55
-#define R_M32R_GOT16_HI_ULO	56
-
-#define R_M32R_GOT16_HI_SLO	57
-
-#define R_M32R_GOT16_LO		58
-#define R_M32R_GOTPC_HI_ULO	59
-
-#define R_M32R_GOTPC_HI_SLO	60
-
-#define R_M32R_GOTPC_LO		61
-
-#define R_M32R_GOTOFF_HI_ULO	62
-
-#define R_M32R_GOTOFF_HI_SLO	63
-
-#define R_M32R_GOTOFF_LO	64
-#define R_M32R_NUM		256
+#define R_X86_64_TLSDESC_CALL 35
+
+#define R_X86_64_TLSDESC 36
+#define R_X86_64_IRELATIVE 37
+#define R_X86_64_RELATIVE64 38
+#define R_X86_64_GOTPCRELX 41
+#define R_X86_64_REX_GOTPCRELX 42
+#define R_X86_64_NUM 43
+
+#define R_MN10300_NONE 0
+#define R_MN10300_32 1
+#define R_MN10300_16 2
+#define R_MN10300_8 3
+#define R_MN10300_PCREL32 4
+#define R_MN10300_PCREL16 5
+#define R_MN10300_PCREL8 6
+#define R_MN10300_GNU_VTINHERIT 7
+#define R_MN10300_GNU_VTENTRY 8
+#define R_MN10300_24 9
+#define R_MN10300_GOTPC32 10
+#define R_MN10300_GOTPC16 11
+#define R_MN10300_GOTOFF32 12
+#define R_MN10300_GOTOFF24 13
+#define R_MN10300_GOTOFF16 14
+#define R_MN10300_PLT32 15
+#define R_MN10300_PLT16 16
+#define R_MN10300_GOT32 17
+#define R_MN10300_GOT24 18
+#define R_MN10300_GOT16 19
+#define R_MN10300_COPY 20
+#define R_MN10300_GLOB_DAT 21
+#define R_MN10300_JMP_SLOT 22
+#define R_MN10300_RELATIVE 23
+
+#define R_MN10300_NUM 24
+
+#define R_M32R_NONE 0
+#define R_M32R_16 1
+#define R_M32R_32 2
+#define R_M32R_24 3
+#define R_M32R_10_PCREL 4
+#define R_M32R_18_PCREL 5
+#define R_M32R_26_PCREL 6
+#define R_M32R_HI16_ULO 7
+#define R_M32R_HI16_SLO 8
+#define R_M32R_LO16 9
+#define R_M32R_SDA16 10
+#define R_M32R_GNU_VTINHERIT 11
+#define R_M32R_GNU_VTENTRY 12
+
+#define R_M32R_16_RELA 33
+#define R_M32R_32_RELA 34
+#define R_M32R_24_RELA 35
+#define R_M32R_10_PCREL_RELA 36
+#define R_M32R_18_PCREL_RELA 37
+#define R_M32R_26_PCREL_RELA 38
+#define R_M32R_HI16_ULO_RELA 39
+#define R_M32R_HI16_SLO_RELA 40
+#define R_M32R_LO16_RELA 41
+#define R_M32R_SDA16_RELA 42
+#define R_M32R_RELA_GNU_VTINHERIT 43
+#define R_M32R_RELA_GNU_VTENTRY 44
+#define R_M32R_REL32 45
+
+#define R_M32R_GOT24 48
+#define R_M32R_26_PLTREL 49
+#define R_M32R_COPY 50
+#define R_M32R_GLOB_DAT 51
+#define R_M32R_JMP_SLOT 52
+#define R_M32R_RELATIVE 53
+#define R_M32R_GOTOFF 54
+#define R_M32R_GOTPC24 55
+#define R_M32R_GOT16_HI_ULO 56
+
+#define R_M32R_GOT16_HI_SLO 57
+
+#define R_M32R_GOT16_LO 58
+#define R_M32R_GOTPC_HI_ULO 59
+
+#define R_M32R_GOTPC_HI_SLO 60
+
+#define R_M32R_GOTPC_LO 61
+
+#define R_M32R_GOTOFF_HI_ULO 62
+
+#define R_M32R_GOTOFF_HI_SLO 63
+
+#define R_M32R_GOTOFF_LO 64
+#define R_M32R_NUM 256
 
 #define R_MICROBLAZE_NONE 0
 #define R_MICROBLAZE_32 1
@@ -3049,99 +2816,98 @@ enum
 #define R_MICROBLAZE_TLSDTPREL32 26
 #define R_MICROBLAZE_TLSDTPREL64 27
 #define R_MICROBLAZE_TLSGOTTPREL32 28
-#define R_MICROBLAZE_TLSTPREL32	 29
-
-#define DT_NIOS2_GP             0x70000002
-
-#define R_NIOS2_NONE		0
-#define R_NIOS2_S16		1
-#define R_NIOS2_U16		2
-#define R_NIOS2_PCREL16		3
-#define R_NIOS2_CALL26		4
-#define R_NIOS2_IMM5		5
-#define R_NIOS2_CACHE_OPX	6
-#define R_NIOS2_IMM6		7
-#define R_NIOS2_IMM8		8
-#define R_NIOS2_HI16		9
-#define R_NIOS2_LO16		10
-#define R_NIOS2_HIADJ16		11
-#define R_NIOS2_BFD_RELOC_32	12
-#define R_NIOS2_BFD_RELOC_16	13
-#define R_NIOS2_BFD_RELOC_8	14
-#define R_NIOS2_GPREL		15
-#define R_NIOS2_GNU_VTINHERIT	16
-#define R_NIOS2_GNU_VTENTRY	17
-#define R_NIOS2_UJMP		18
-#define R_NIOS2_CJMP		19
-#define R_NIOS2_CALLR		20
-#define R_NIOS2_ALIGN		21
-#define R_NIOS2_GOT16		22
-#define R_NIOS2_CALL16		23
-#define R_NIOS2_GOTOFF_LO	24
-#define R_NIOS2_GOTOFF_HA	25
-#define R_NIOS2_PCREL_LO	26
-#define R_NIOS2_PCREL_HA	27
-#define R_NIOS2_TLS_GD16	28
-#define R_NIOS2_TLS_LDM16	29
-#define R_NIOS2_TLS_LDO16	30
-#define R_NIOS2_TLS_IE16	31
-#define R_NIOS2_TLS_LE16	32
-#define R_NIOS2_TLS_DTPMOD	33
-#define R_NIOS2_TLS_DTPREL	34
-#define R_NIOS2_TLS_TPREL	35
-#define R_NIOS2_COPY		36
-#define R_NIOS2_GLOB_DAT	37
-#define R_NIOS2_JUMP_SLOT	38
-#define R_NIOS2_RELATIVE	39
-#define R_NIOS2_GOTOFF		40
-#define R_NIOS2_CALL26_NOAT	41
-#define R_NIOS2_GOT_LO		42
-#define R_NIOS2_GOT_HA		43
-#define R_NIOS2_CALL_LO		44
-#define R_NIOS2_CALL_HA		45
-
-#define R_OR1K_NONE		0
-#define R_OR1K_32		1
-#define R_OR1K_16		2
-#define R_OR1K_8		3
-#define R_OR1K_LO_16_IN_INSN	4
-#define R_OR1K_HI_16_IN_INSN	5
-#define R_OR1K_INSN_REL_26	6
-#define R_OR1K_GNU_VTENTRY	7
-#define R_OR1K_GNU_VTINHERIT	8
-#define R_OR1K_32_PCREL		9
-#define R_OR1K_16_PCREL		10
-#define R_OR1K_8_PCREL		11
-#define R_OR1K_GOTPC_HI16	12
-#define R_OR1K_GOTPC_LO16	13
-#define R_OR1K_GOT16		14
-#define R_OR1K_PLT26		15
-#define R_OR1K_GOTOFF_HI16	16
-#define R_OR1K_GOTOFF_LO16	17
-#define R_OR1K_COPY		18
-#define R_OR1K_GLOB_DAT		19
-#define R_OR1K_JMP_SLOT		20
-#define R_OR1K_RELATIVE		21
-#define R_OR1K_TLS_GD_HI16	22
-#define R_OR1K_TLS_GD_LO16	23
-#define R_OR1K_TLS_LDM_HI16	24
-#define R_OR1K_TLS_LDM_LO16	25
-#define R_OR1K_TLS_LDO_HI16	26
-#define R_OR1K_TLS_LDO_LO16	27
-#define R_OR1K_TLS_IE_HI16	28
-#define R_OR1K_TLS_IE_LO16	29
-#define R_OR1K_TLS_LE_HI16	30
-#define R_OR1K_TLS_LE_LO16	31
-#define R_OR1K_TLS_TPOFF	32
-#define R_OR1K_TLS_DTPOFF	33
-#define R_OR1K_TLS_DTPMOD	34
-
-#define R_BPF_NONE		0
-#define R_BPF_MAP_FD		1
+#define R_MICROBLAZE_TLSTPREL32 29
+
+#define DT_NIOS2_GP 0x70000002
+
+#define R_NIOS2_NONE 0
+#define R_NIOS2_S16 1
+#define R_NIOS2_U16 2
+#define R_NIOS2_PCREL16 3
+#define R_NIOS2_CALL26 4
+#define R_NIOS2_IMM5 5
+#define R_NIOS2_CACHE_OPX 6
+#define R_NIOS2_IMM6 7
+#define R_NIOS2_IMM8 8
+#define R_NIOS2_HI16 9
+#define R_NIOS2_LO16 10
+#define R_NIOS2_HIADJ16 11
+#define R_NIOS2_BFD_RELOC_32 12
+#define R_NIOS2_BFD_RELOC_16 13
+#define R_NIOS2_BFD_RELOC_8 14
+#define R_NIOS2_GPREL 15
+#define R_NIOS2_GNU_VTINHERIT 16
+#define R_NIOS2_GNU_VTENTRY 17
+#define R_NIOS2_UJMP 18
+#define R_NIOS2_CJMP 19
+#define R_NIOS2_CALLR 20
+#define R_NIOS2_ALIGN 21
+#define R_NIOS2_GOT16 22
+#define R_NIOS2_CALL16 23
+#define R_NIOS2_GOTOFF_LO 24
+#define R_NIOS2_GOTOFF_HA 25
+#define R_NIOS2_PCREL_LO 26
+#define R_NIOS2_PCREL_HA 27
+#define R_NIOS2_TLS_GD16 28
+#define R_NIOS2_TLS_LDM16 29
+#define R_NIOS2_TLS_LDO16 30
+#define R_NIOS2_TLS_IE16 31
+#define R_NIOS2_TLS_LE16 32
+#define R_NIOS2_TLS_DTPMOD 33
+#define R_NIOS2_TLS_DTPREL 34
+#define R_NIOS2_TLS_TPREL 35
+#define R_NIOS2_COPY 36
+#define R_NIOS2_GLOB_DAT 37
+#define R_NIOS2_JUMP_SLOT 38
+#define R_NIOS2_RELATIVE 39
+#define R_NIOS2_GOTOFF 40
+#define R_NIOS2_CALL26_NOAT 41
+#define R_NIOS2_GOT_LO 42
+#define R_NIOS2_GOT_HA 43
+#define R_NIOS2_CALL_LO 44
+#define R_NIOS2_CALL_HA 45
+
+#define R_OR1K_NONE 0
+#define R_OR1K_32 1
+#define R_OR1K_16 2
+#define R_OR1K_8 3
+#define R_OR1K_LO_16_IN_INSN 4
+#define R_OR1K_HI_16_IN_INSN 5
+#define R_OR1K_INSN_REL_26 6
+#define R_OR1K_GNU_VTENTRY 7
+#define R_OR1K_GNU_VTINHERIT 8
+#define R_OR1K_32_PCREL 9
+#define R_OR1K_16_PCREL 10
+#define R_OR1K_8_PCREL 11
+#define R_OR1K_GOTPC_HI16 12
+#define R_OR1K_GOTPC_LO16 13
+#define R_OR1K_GOT16 14
+#define R_OR1K_PLT26 15
+#define R_OR1K_GOTOFF_HI16 16
+#define R_OR1K_GOTOFF_LO16 17
+#define R_OR1K_COPY 18
+#define R_OR1K_GLOB_DAT 19
+#define R_OR1K_JMP_SLOT 20
+#define R_OR1K_RELATIVE 21
+#define R_OR1K_TLS_GD_HI16 22
+#define R_OR1K_TLS_GD_LO16 23
+#define R_OR1K_TLS_LDM_HI16 24
+#define R_OR1K_TLS_LDM_LO16 25
+#define R_OR1K_TLS_LDO_HI16 26
+#define R_OR1K_TLS_LDO_LO16 27
+#define R_OR1K_TLS_IE_HI16 28
+#define R_OR1K_TLS_IE_LO16 29
+#define R_OR1K_TLS_LE_HI16 30
+#define R_OR1K_TLS_LE_LO16 31
+#define R_OR1K_TLS_TPOFF 32
+#define R_OR1K_TLS_DTPOFF 33
+#define R_OR1K_TLS_DTPMOD 34
+
+#define R_BPF_NONE 0
+#define R_BPF_MAP_FD 1
 
 #ifdef __cplusplus
 }
 #endif
 
-
 #endif
diff --git a/tools/src/gbafix/gbafix.c b/tools/src/gbafix/gbafix.c
index 598e43aa..db301c78 100755..100644
--- a/tools/src/gbafix/gbafix.c
+++ b/tools/src/gbafix/gbafix.c
@@ -21,7 +21,8 @@
     Please report all bugs and problems through the bug tracker at
     "http://sourceforge.net/tracker/?group_id=114505&atid=668551".
 
-    "$Header: /lvm/shared/ds/ds/cvs/devkitpro-cvsbackup/tools/gba/gbatools/gbafix.c,v 1.2 2008-07-30 17:12:51 wntrmute Exp $"
+    "$Header: /lvm/shared/ds/ds/cvs/devkitpro-cvsbackup/tools/gba/gbatools/gbafix.c,v 1.2 2008-07-30 17:12:51 wntrmute
+   Exp $"
 
 */
 //---------------------------------------------------------------------------------
@@ -51,49 +52,45 @@
 #include <stdint.h>
 #include "elf.h"
 
-#define VER        "1.07"
-#define ARGV    argv[arg]
-#define VALUE    (ARGV+2)
-#define NUMBER    strtoul(VALUE, NULL, 0)
-
-typedef struct
-{
-    uint32_t    start_code;            // B instruction
-    uint8_t        logo[0xA0-0x04];    // logo data
-    uint8_t        title[0xC];            // game title name
-    uint32_t    game_code;            //
-    uint16_t    maker_code;            //
-    uint8_t        fixed;                // 0x96
-    uint8_t        unit_code;            // 0x00
-    uint8_t        device_type;        // 0x00
-    uint8_t        unused[7];            //
-    uint8_t        game_version;        // 0x00
-    uint8_t        complement;            // 800000A0..800000BC
-    uint16_t    checksum;            // 0x0000
+#define VER "1.07"
+#define ARGV argv[arg]
+#define VALUE (ARGV + 2)
+#define NUMBER strtoul(VALUE, NULL, 0)
+
+typedef struct {
+    uint32_t start_code;       // B instruction
+    uint8_t logo[0xA0 - 0x04]; // logo data
+    uint8_t title[0xC];        // game title name
+    uint32_t game_code;        //
+    uint16_t maker_code;       //
+    uint8_t fixed;             // 0x96
+    uint8_t unit_code;         // 0x00
+    uint8_t device_type;       // 0x00
+    uint8_t unused[7];         //
+    uint8_t game_version;      // 0x00
+    uint8_t complement;        // 800000A0..800000BC
+    uint16_t checksum;         // 0x0000
 } Header;
 
-
 Header header;
 
 unsigned short checksum_without_header = 0;
 
-const Header good_header =
-{
+const Header good_header = {
     // start_code
     0xEA00002E,
     // logo
-    { 0x24,0xFF,0xAE,0x51,0x69,0x9A,0xA2,0x21,0x3D,0x84,0x82,0x0A,0x84,0xE4,0x09,0xAD,
-    0x11,0x24,0x8B,0x98,0xC0,0x81,0x7F,0x21,0xA3,0x52,0xBE,0x19,0x93,0x09,0xCE,0x20,
-    0x10,0x46,0x4A,0x4A,0xF8,0x27,0x31,0xEC,0x58,0xC7,0xE8,0x33,0x82,0xE3,0xCE,0xBF,
-    0x85,0xF4,0xDF,0x94,0xCE,0x4B,0x09,0xC1,0x94,0x56,0x8A,0xC0,0x13,0x72,0xA7,0xFC,
-    0x9F,0x84,0x4D,0x73,0xA3,0xCA,0x9A,0x61,0x58,0x97,0xA3,0x27,0xFC,0x03,0x98,0x76,
-    0x23,0x1D,0xC7,0x61,0x03,0x04,0xAE,0x56,0xBF,0x38,0x84,0x00,0x40,0xA7,0x0E,0xFD,
-    0xFF,0x52,0xFE,0x03,0x6F,0x95,0x30,0xF1,0x97,0xFB,0xC0,0x85,0x60,0xD6,0x80,0x25,
-    0xA9,0x63,0xBE,0x03,0x01,0x4E,0x38,0xE2,0xF9,0xA2,0x34,0xFF,0xBB,0x3E,0x03,0x44,
-    0x78,0x00,0x90,0xCB,0x88,0x11,0x3A,0x94,0x65,0xC0,0x7C,0x63,0x87,0xF0,0x3C,0xAF,
-    0xD6,0x25,0xE4,0x8B,0x38,0x0A,0xAC,0x72,0x21,0xD4,0xF8,0x07 } ,
+    { 0x24, 0xFF, 0xAE, 0x51, 0x69, 0x9A, 0xA2, 0x21, 0x3D, 0x84, 0x82, 0x0A, 0x84, 0xE4, 0x09, 0xAD, 0x11, 0x24,
+      0x8B, 0x98, 0xC0, 0x81, 0x7F, 0x21, 0xA3, 0x52, 0xBE, 0x19, 0x93, 0x09, 0xCE, 0x20, 0x10, 0x46, 0x4A, 0x4A,
+      0xF8, 0x27, 0x31, 0xEC, 0x58, 0xC7, 0xE8, 0x33, 0x82, 0xE3, 0xCE, 0xBF, 0x85, 0xF4, 0xDF, 0x94, 0xCE, 0x4B,
+      0x09, 0xC1, 0x94, 0x56, 0x8A, 0xC0, 0x13, 0x72, 0xA7, 0xFC, 0x9F, 0x84, 0x4D, 0x73, 0xA3, 0xCA, 0x9A, 0x61,
+      0x58, 0x97, 0xA3, 0x27, 0xFC, 0x03, 0x98, 0x76, 0x23, 0x1D, 0xC7, 0x61, 0x03, 0x04, 0xAE, 0x56, 0xBF, 0x38,
+      0x84, 0x00, 0x40, 0xA7, 0x0E, 0xFD, 0xFF, 0x52, 0xFE, 0x03, 0x6F, 0x95, 0x30, 0xF1, 0x97, 0xFB, 0xC0, 0x85,
+      0x60, 0xD6, 0x80, 0x25, 0xA9, 0x63, 0xBE, 0x03, 0x01, 0x4E, 0x38, 0xE2, 0xF9, 0xA2, 0x34, 0xFF, 0xBB, 0x3E,
+      0x03, 0x44, 0x78, 0x00, 0x90, 0xCB, 0x88, 0x11, 0x3A, 0x94, 0x65, 0xC0, 0x7C, 0x63, 0x87, 0xF0, 0x3C, 0xAF,
+      0xD6, 0x25, 0xE4, 0x8B, 0x38, 0x0A, 0xAC, 0x72, 0x21, 0xD4, 0xF8, 0x07 },
     // title
-    { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
     // game code
     0x00000000,
     // maker code
@@ -105,7 +102,7 @@ const Header good_header =
     // device type
     0x00,
     // unused
-    { 0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
     // game version
     0x00,
     // complement
@@ -122,32 +119,30 @@ char HeaderComplement()
 {
     int n;
     char c = 0;
-    char *p = (char *)&header + 0xA0;
-    for (n=0; n<0xBD-0xA0; n++)
-    {
+    char* p = (char*)&header + 0xA0;
+    for (n = 0; n < 0xBD - 0xA0; n++) {
         c += *p++;
     }
-    return -(0x19+c);
+    return -(0x19 + c);
 }
 
-
 //---------------------------------------------------------------------------------
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 //---------------------------------------------------------------------------------
 {
     int arg;
-    char *argfile = 0;
-    FILE *infile;
+    char* argfile = 0;
+    FILE* infile;
     int silent = 0;
     int schedule_pad = 0;
 
-    int size,bit;
+    int size, bit;
 
     // show syntax
-    if (argc <= 1)
-    {
-        printf("GBA ROM fixer v"VER" by Dark Fader / BlackThunder / WinterMute / Diegoisawesome \n");
-        printf("Syntax: gbafix <rom.gba> [-p] [-t[title]] [-c<game_code>] [-m<maker_code>] [-r<version>] [-d<debug>] [--silent]\n");
+    if (argc <= 1) {
+        printf("GBA ROM fixer v" VER " by Dark Fader / BlackThunder / WinterMute / Diegoisawesome \n");
+        printf("Syntax: gbafix <rom.gba> [-p] [-t[title]] [-c<game_code>] [-m<maker_code>] [-r<version>] [-d<debug>] "
+               "[--silent]\n");
         printf("\n");
         printf("parameters:\n");
         printf("    -p              Pad to next exact power of 2. No minimum size!\n");
@@ -161,15 +156,17 @@ int main(int argc, char *argv[])
     }
 
     // get filename
-    for (arg=1; arg<argc; arg++)
-    {
-        if (ARGV[0] != '-') { argfile=ARGV; }
-        if (strncmp("--silent", &ARGV[0], 7) == 0) { silent = 1; }
+    for (arg = 1; arg < argc; arg++) {
+        if (ARGV[0] != '-') {
+            argfile = ARGV;
+        }
+        if (strncmp("--silent", &ARGV[0], 7) == 0) {
+            silent = 1;
+        }
     }
 
     // check filename
-    if (!argfile)
-    {
+    if (!argfile) {
         fprintf(stderr, "Filename needed!\n");
         return -1;
     }
@@ -178,21 +175,28 @@ int main(int argc, char *argv[])
 
     // read file
     infile = fopen(argfile, "r+b");
-    if (!infile) { fprintf(stderr, "Error opening input file!\n"); return -1; }
+    if (!infile) {
+        fprintf(stderr, "Error opening input file!\n");
+        return -1;
+    }
     fseek(infile, sh_offset, SEEK_SET);
     fread(&header, sizeof(header), 1, infile);
 
     // elf check
     Elf32_Shdr secHeader;
     if (memcmp(&header, ELFMAG, 4) == 0) {
-        Elf32_Ehdr *elfHeader = (Elf32_Ehdr *)&header;
+        Elf32_Ehdr* elfHeader = (Elf32_Ehdr*)&header;
         fseek(infile, elfHeader->e_shoff, SEEK_SET);
         int i;
         for (i = 0; i < elfHeader->e_shnum; i++) {
             fread(&secHeader, sizeof(Elf32_Shdr), 1, infile);
-            if (secHeader.sh_type == SHT_PROGBITS && secHeader.sh_addr == elfHeader->e_entry) break;
+            if (secHeader.sh_type == SHT_PROGBITS && secHeader.sh_addr == elfHeader->e_entry)
+                break;
+        }
+        if (i == elfHeader->e_shnum) {
+            fprintf(stderr, "Error finding entry point!\n");
+            return 1;
         }
-        if (i == elfHeader->e_shnum) { fprintf(stderr, "Error finding entry point!\n"); return 1; }
         fseek(infile, secHeader.sh_offset, SEEK_SET);
         sh_offset = secHeader.sh_offset;
         fread(&header, sizeof(header), 1, infile);
@@ -204,82 +208,91 @@ int main(int argc, char *argv[])
     memcpy(&header.device_type, &good_header.device_type, sizeof(header.device_type));
 
     // parse command line
-    for (arg=1; arg<argc; arg++)
-    {
-        if (ARGV[0] == '-')
-        {
-            switch (ARGV[1])
-            {
-                case 'p':    // pad
+    for (arg = 1; arg < argc; arg++) {
+        if (ARGV[0] == '-') {
+            switch (ARGV[1]) {
+                case 'p': // pad
                 {
                     schedule_pad = 1;
                     break;
                 }
 
-                case 't':    // title
+                case 't': // title
                 {
                     char title[256];
                     memset(title, 0, sizeof(title));
-                    if (VALUE[0])
-                    {
+                    if (VALUE[0]) {
                         strncpy(title, VALUE, sizeof(header.title));
-                    }
-                    else
-                    {
+                    } else {
                         // use filename
-                        char s[256], *begin=s, *t; strcpy(s, argfile);
-                        t = strrchr(s, '\\'); if (t) begin = t+1;
-                        t = strrchr(s, '/'); if (t) begin = t+1;
-                        t = strrchr(s, '.'); if (t) *t = 0;
+                        char s[256], *begin = s, *t;
+                        strcpy(s, argfile);
+                        t = strrchr(s, '\\');
+                        if (t)
+                            begin = t + 1;
+                        t = strrchr(s, '/');
+                        if (t)
+                            begin = t + 1;
+                        t = strrchr(s, '.');
+                        if (t)
+                            *t = 0;
                         strncpy(title, begin, sizeof(header.title));
-                        if (!silent) printf("%s\n",begin);
+                        if (!silent)
+                            printf("%s\n", begin);
                     }
-                    memcpy(header.title, title, sizeof(header.title));    // copy
+                    memcpy(header.title, title, sizeof(header.title)); // copy
                     break;
                 }
 
-                case 'c':    // game code
+                case 'c': // game code
                 {
-                    //if (!VALUE[0]) { fprintf(stderr, "Need value for %s\n", ARGV); break; }
-                    //header.game_code = NUMBER;
-                    header.game_code = VALUE[0] | VALUE[1]<<8 | VALUE[2]<<16 | VALUE[3]<<24;
+                    // if (!VALUE[0]) { fprintf(stderr, "Need value for %s\n", ARGV); break; }
+                    // header.game_code = NUMBER;
+                    header.game_code = VALUE[0] | VALUE[1] << 8 | VALUE[2] << 16 | VALUE[3] << 24;
                     break;
                 }
 
-                case 'm':    // maker code
+                case 'm': // maker code
                 {
-                    //if (!VALUE[0]) { fprintf(stderr, "Need value for %s\n", ARGV); break; }
-                    //header.maker_code = (unsigned short)NUMBER;
-                    header.maker_code = VALUE[0] | VALUE[1]<<8;
+                    // if (!VALUE[0]) { fprintf(stderr, "Need value for %s\n", ARGV); break; }
+                    // header.maker_code = (unsigned short)NUMBER;
+                    header.maker_code = VALUE[0] | VALUE[1] << 8;
                     break;
                 }
 
-                case 'v':    // ignored, compatability with other gbafix
+                case 'v': // ignored, compatability with other gbafix
                 {
                     break;
                 }
 
-                case 'r':    // version
+                case 'r': // version
                 {
-                    if (!VALUE[0]) { fprintf(stderr, "Need value for %s\n", ARGV); break; }
+                    if (!VALUE[0]) {
+                        fprintf(stderr, "Need value for %s\n", ARGV);
+                        break;
+                    }
                     header.game_version = (unsigned char)NUMBER;
                     break;
                 }
 
-                case 'd':    // debug
+                case 'd': // debug
                 {
-                    if (!VALUE[0]) { fprintf(stderr, "Need value for %s\n", ARGV); break; }
-                    header.logo[0x9C-0x04] = 0xA5;    // debug enable
-                    header.device_type = (unsigned char)((NUMBER & 1) << 7);    // debug handler entry point
+                    if (!VALUE[0]) {
+                        fprintf(stderr, "Need value for %s\n", ARGV);
+                        break;
+                    }
+                    header.logo[0x9C - 0x04] = 0xA5;                         // debug enable
+                    header.device_type = (unsigned char)((NUMBER & 1) << 7); // debug handler entry point
                     break;
                 }
-                case '-':    // long arguments
+                case '-': // long arguments
                 {
-                    if (strncmp("silent", &ARGV[2], 6) == 0) { continue; }
+                    if (strncmp("silent", &ARGV[2], 6) == 0) {
+                        continue;
+                    }
                     break;
                 }
-            default:
-                {
+                default: {
                     printf("Invalid option: %s\n", ARGV);
                 }
             }
@@ -288,9 +301,9 @@ int main(int argc, char *argv[])
 
     // update complement check & total checksum
     header.complement = 0;
-    header.checksum = 0;    // must be 0
+    header.checksum = 0; // must be 0
     header.complement = HeaderComplement();
-    //header.checksum = checksum_without_header + HeaderChecksum();
+    // header.checksum = checksum_without_header + HeaderChecksum();
 
     if (schedule_pad) {
         if (sh_offset != 0) {
@@ -298,11 +311,13 @@ int main(int argc, char *argv[])
         } else {
             fseek(infile, 0, SEEK_END);
             size = ftell(infile);
-            for (bit=31; bit>=0; bit--) if (size & (1<<bit)) break;
-            if (size != (1<<bit))
-            {
-                int todo = (1<<(bit+1)) - size;
-                while (todo--) fputc(0xFF, infile);
+            for (bit = 31; bit >= 0; bit--)
+                if (size & (1 << bit))
+                    break;
+            if (size != (1 << bit)) {
+                int todo = (1 << (bit + 1)) - size;
+                while (todo--)
+                    fputc(0xFF, infile);
             }
         }
     }
@@ -311,7 +326,8 @@ int main(int argc, char *argv[])
     fwrite(&header, sizeof(header), 1, infile);
     fclose(infile);
 
-    if (!silent) printf("ROM fixed!\n");
+    if (!silent)
+        printf("ROM fixed!\n");
 
     return 0;
 }
diff --git a/tools/src/gbagfx/convert_png.c b/tools/src/gbagfx/convert_png.c
index cdfa39a7..61760836 100755..100644
--- a/tools/src/gbagfx/convert_png.c
+++ b/tools/src/gbagfx/convert_png.c
@@ -7,9 +7,8 @@
 #include "convert_png.h"
 #include "gfx.h"
 
-static FILE *PngReadOpen(char *path, png_structp *pngStruct, png_infop *pngInfo)
-{
-    FILE *fp = fopen(path, "rb");
+static FILE* PngReadOpen(char* path, png_structp* pngStruct, png_infop* pngInfo) {
+    FILE* fp = fopen(path, "rb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open \"%s\" for reading.\n", path);
@@ -45,31 +44,27 @@ static FILE *PngReadOpen(char *path, png_structp *pngStruct, png_infop *pngInfo)
     return fp;
 }
 
-static unsigned char *ConvertBitDepth(unsigned char *src, int srcBitDepth, int destBitDepth, int numPixels)
-{
+static unsigned char* ConvertBitDepth(unsigned char* src, int srcBitDepth, int destBitDepth, int numPixels) {
     // Round the number of bits up to the next 8 and divide by 8 to get the number of bytes.
     int srcSize = ((numPixels * srcBitDepth + 7) & ~7) / 8;
     int destSize = ((numPixels * destBitDepth + 7) & ~7) / 8;
-    unsigned char *output = calloc(destSize, 1);
-    unsigned char *dest = output;
+    unsigned char* output = calloc(destSize, 1);
+    unsigned char* dest = output;
     int i;
     int j;
     int destBit = 8 - destBitDepth;
 
-    for (i = 0; i < srcSize; i++)
-    {
+    for (i = 0; i < srcSize; i++) {
         unsigned char srcByte = src[i];
 
-        for (j = 8 - srcBitDepth; j >= 0; j -= srcBitDepth)
-        {
+        for (j = 8 - srcBitDepth; j >= 0; j -= srcBitDepth) {
             unsigned char pixel = (srcByte >> j) % (1 << srcBitDepth);
 
             if (pixel >= (1 << destBitDepth))
                 FATAL_ERROR("Image exceeds the maximum color value for a %ibpp image.\n", destBitDepth);
             *dest |= pixel << destBit;
             destBit -= destBitDepth;
-            if (destBit < 0)
-            {
+            if (destBit < 0) {
                 dest++;
                 destBit = 8 - destBitDepth;
             }
@@ -79,12 +74,11 @@ static unsigned char *ConvertBitDepth(unsigned char *src, int srcBitDepth, int d
     return output;
 }
 
-void ReadPng(char *path, struct Image *image)
-{
+void ReadPng(char* path, struct Image* image) {
     png_structp png_ptr;
     png_infop info_ptr;
 
-    FILE *fp = PngReadOpen(path, &png_ptr, &info_ptr);
+    FILE* fp = PngReadOpen(path, &png_ptr, &info_ptr);
 
     int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
 
@@ -125,9 +119,8 @@ void ReadPng(char *path, struct Image *image)
     free(row_pointers);
     fclose(fp);
 
-    if (bit_depth != image->bitDepth)
-    {
-        unsigned char *src = image->pixels;
+    if (bit_depth != image->bitDepth) {
+        unsigned char* src = image->pixels;
 
         if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && bit_depth != 8)
             FATAL_ERROR("Bit depth of image must be 1, 2, 4, or 8.\n");
@@ -137,14 +130,13 @@ void ReadPng(char *path, struct Image *image)
     }
 }
 
-void ReadPngPalette(char *path, struct Palette *palette)
-{
+void ReadPngPalette(char* path, struct Palette* palette) {
     png_structp png_ptr;
     png_infop info_ptr;
     png_colorp colors;
     int numColors;
 
-    FILE *fp = PngReadOpen(path, &png_ptr, &info_ptr);
+    FILE* fp = PngReadOpen(path, &png_ptr, &info_ptr);
 
     if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE)
         FATAL_ERROR("The image \"%s\" does not contain a palette.\n", path);
@@ -167,8 +159,7 @@ void ReadPngPalette(char *path, struct Palette *palette)
     fclose(fp);
 }
 
-void SetPngPalette(png_structp png_ptr, png_infop info_ptr, struct Palette *palette)
-{
+void SetPngPalette(png_structp png_ptr, png_infop info_ptr, struct Palette* palette) {
     png_colorp colors = malloc(palette->numColors * sizeof(png_color));
 
     if (colors == NULL)
@@ -185,9 +176,8 @@ void SetPngPalette(png_structp png_ptr, png_infop info_ptr, struct Palette *pale
     free(colors);
 }
 
-void WritePng(char *path, struct Image *image)
-{
-    FILE *fp = fopen(path, "wb");
+void WritePng(char* path, struct Image* image) {
+    FILE* fp = fopen(path, "wb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open \"%s\" for writing.\n", path);
@@ -212,9 +202,8 @@ void WritePng(char *path, struct Image *image)
 
     int color_type = image->hasPalette ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_GRAY;
 
-    png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
-        image->bitDepth, color_type, PNG_INTERLACE_NONE,
-        PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+    png_set_IHDR(png_ptr, info_ptr, image->width, image->height, image->bitDepth, color_type, PNG_INTERLACE_NONE,
+                 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 
     if (image->hasPalette) {
         SetPngPalette(png_ptr, info_ptr, &image->palette);
diff --git a/tools/src/gbagfx/convert_png.h b/tools/src/gbagfx/convert_png.h
index caf081b7..d45531ed 100755..100644
--- a/tools/src/gbagfx/convert_png.h
+++ b/tools/src/gbagfx/convert_png.h
@@ -5,8 +5,8 @@
 
 #include "gfx.h"
 
-void ReadPng(char *path, struct Image *image);
-void WritePng(char *path, struct Image *image);
-void ReadPngPalette(char *path, struct Palette *palette);
+void ReadPng(char* path, struct Image* image);
+void WritePng(char* path, struct Image* image);
+void ReadPngPalette(char* path, struct Palette* palette);
 
 #endif // CONVERT_PNG_H
diff --git a/tools/src/gbagfx/font.c b/tools/src/gbagfx/font.c
index 0dd6fbc3..366b78b3 100755..100644
--- a/tools/src/gbagfx/font.c
+++ b/tools/src/gbagfx/font.c
@@ -10,317 +10,306 @@
 #include "util.h"
 
 unsigned char gFontPalette[][3] = {
-	{0x90, 0xC8, 0xFF}, // bg (saturated blue that contrasts well with the shadow color)
-	{0x38, 0x38, 0x38}, // fg (dark grey)
-	{0xD8, 0xD8, 0xD8}, // shadow (light grey)
-	{0xFF, 0xFF, 0xFF}  // box (white)
+    { 0x90, 0xC8, 0xFF }, // bg (saturated blue that contrasts well with the shadow color)
+    { 0x38, 0x38, 0x38 }, // fg (dark grey)
+    { 0xD8, 0xD8, 0xD8 }, // shadow (light grey)
+    { 0xFF, 0xFF, 0xFF }  // box (white)
 };
 
-static void ConvertFromLatinFont(unsigned char *src, unsigned char *dest, unsigned int numRows)
-{
-	unsigned int srcPixelsOffset = 0;
+static void ConvertFromLatinFont(unsigned char* src, unsigned char* dest, unsigned int numRows) {
+    unsigned int srcPixelsOffset = 0;
 
-	for (unsigned int row = 0; row < numRows; row++) {
-		for (unsigned int column = 0; column < 16; column++) {
-			for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
-				unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
+    for (unsigned int row = 0; row < numRows; row++) {
+        for (unsigned int column = 0; column < 16; column++) {
+            for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
+                unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
 
-				for (unsigned int i = 0; i < 8; i++) {
-					unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;				
-					unsigned int destPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
+                for (unsigned int i = 0; i < 8; i++) {
+                    unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;
+                    unsigned int destPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
 
-					dest[destPixelsOffset] = src[srcPixelsOffset + 1];
-					dest[destPixelsOffset + 1] = src[srcPixelsOffset];
+                    dest[destPixelsOffset] = src[srcPixelsOffset + 1];
+                    dest[destPixelsOffset + 1] = src[srcPixelsOffset];
 
-					srcPixelsOffset += 2;
-				}
-			}
-		}
-	}
+                    srcPixelsOffset += 2;
+                }
+            }
+        }
+    }
 }
 
-static void ConvertToLatinFont(unsigned char *src, unsigned char *dest, unsigned int numRows)
-{
-	unsigned int destPixelsOffset = 0;
+static void ConvertToLatinFont(unsigned char* src, unsigned char* dest, unsigned int numRows) {
+    unsigned int destPixelsOffset = 0;
 
-	for (unsigned int row = 0; row < numRows; row++) {
-		for (unsigned int column = 0; column < 16; column++) {
-			for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
-				unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
+    for (unsigned int row = 0; row < numRows; row++) {
+        for (unsigned int column = 0; column < 16; column++) {
+            for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
+                unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
 
-				for (unsigned int i = 0; i < 8; i++) {
-					unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;
-					unsigned int srcPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
+                for (unsigned int i = 0; i < 8; i++) {
+                    unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;
+                    unsigned int srcPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
 
-					dest[destPixelsOffset] = src[srcPixelsOffset + 1];
-					dest[destPixelsOffset + 1] = src[srcPixelsOffset];
+                    dest[destPixelsOffset] = src[srcPixelsOffset + 1];
+                    dest[destPixelsOffset + 1] = src[srcPixelsOffset];
 
-					destPixelsOffset += 2;
-				}
-			}
-		}
-	}
+                    destPixelsOffset += 2;
+                }
+            }
+        }
+    }
 }
 
-static void ConvertFromHalfwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows)
-{
-	for (unsigned int row = 0; row < numRows; row++) {
-		for (unsigned int column = 0; column < 16; column++) {
-			unsigned int glyphIndex = (row * 16) + column;
-
-			for (unsigned int glyphTile = 0; glyphTile < 2; glyphTile++) {
-				unsigned int pixelsX = column * 8;
-				unsigned int srcPixelsOffset = 512 * (glyphIndex >> 4) + 16 * (glyphIndex & 0xF) + 256 * glyphTile;
-
-				for (unsigned int i = 0; i < 8; i++) {
-					unsigned int pixelsY = (row * 16) + (glyphTile * 8) + i;
-					unsigned int destPixelsOffset = (pixelsY * 32) + (pixelsX / 4);
-					
-					dest[destPixelsOffset] = src[srcPixelsOffset + 1];
-					dest[destPixelsOffset + 1] = src[srcPixelsOffset];
-
-					srcPixelsOffset += 2;
-				}
-			}
-		}
-	}
+static void ConvertFromHalfwidthJapaneseFont(unsigned char* src, unsigned char* dest, unsigned int numRows) {
+    for (unsigned int row = 0; row < numRows; row++) {
+        for (unsigned int column = 0; column < 16; column++) {
+            unsigned int glyphIndex = (row * 16) + column;
+
+            for (unsigned int glyphTile = 0; glyphTile < 2; glyphTile++) {
+                unsigned int pixelsX = column * 8;
+                unsigned int srcPixelsOffset = 512 * (glyphIndex >> 4) + 16 * (glyphIndex & 0xF) + 256 * glyphTile;
+
+                for (unsigned int i = 0; i < 8; i++) {
+                    unsigned int pixelsY = (row * 16) + (glyphTile * 8) + i;
+                    unsigned int destPixelsOffset = (pixelsY * 32) + (pixelsX / 4);
+
+                    dest[destPixelsOffset] = src[srcPixelsOffset + 1];
+                    dest[destPixelsOffset + 1] = src[srcPixelsOffset];
+
+                    srcPixelsOffset += 2;
+                }
+            }
+        }
+    }
 }
 
-static void ConvertToHalfwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows)
-{
-	for (unsigned int row = 0; row < numRows; row++) {
-		for (unsigned int column = 0; column < 16; column++) {
-			unsigned int glyphIndex = (row * 16) + column;
+static void ConvertToHalfwidthJapaneseFont(unsigned char* src, unsigned char* dest, unsigned int numRows) {
+    for (unsigned int row = 0; row < numRows; row++) {
+        for (unsigned int column = 0; column < 16; column++) {
+            unsigned int glyphIndex = (row * 16) + column;
 
-			for (unsigned int glyphTile = 0; glyphTile < 2; glyphTile++) {
-				unsigned int pixelsX = column * 8;
-				unsigned int destPixelsOffset = 512 * (glyphIndex >> 4) + 16 * (glyphIndex & 0xF) + 256 * glyphTile;
+            for (unsigned int glyphTile = 0; glyphTile < 2; glyphTile++) {
+                unsigned int pixelsX = column * 8;
+                unsigned int destPixelsOffset = 512 * (glyphIndex >> 4) + 16 * (glyphIndex & 0xF) + 256 * glyphTile;
 
-				for (unsigned int i = 0; i < 8; i++) {
-					unsigned int pixelsY = (row * 16) + (glyphTile * 8) + i;
-					unsigned int srcPixelsOffset = (pixelsY * 32) + (pixelsX / 4);
+                for (unsigned int i = 0; i < 8; i++) {
+                    unsigned int pixelsY = (row * 16) + (glyphTile * 8) + i;
+                    unsigned int srcPixelsOffset = (pixelsY * 32) + (pixelsX / 4);
 
-					dest[destPixelsOffset] = src[srcPixelsOffset + 1];
-					dest[destPixelsOffset + 1] = src[srcPixelsOffset];
+                    dest[destPixelsOffset] = src[srcPixelsOffset + 1];
+                    dest[destPixelsOffset + 1] = src[srcPixelsOffset];
 
-					destPixelsOffset += 2;
-				}
-			}
-		}
-	}
+                    destPixelsOffset += 2;
+                }
+            }
+        }
+    }
 }
 
-static void ConvertFromFullwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows)
-{
-	for (unsigned int row = 0; row < numRows; row++) {
-		for (unsigned int column = 0; column < 16; column++) {
-			unsigned int glyphIndex = (row * 16) + column;
+static void ConvertFromFullwidthJapaneseFont(unsigned char* src, unsigned char* dest, unsigned int numRows) {
+    for (unsigned int row = 0; row < numRows; row++) {
+        for (unsigned int column = 0; column < 16; column++) {
+            unsigned int glyphIndex = (row * 16) + column;
 
-			for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
-				unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
-				unsigned int srcPixelsOffset = 512 * (glyphIndex >> 3) + 32 * (glyphIndex & 7) + 256 * (glyphTile >> 1) + 16 * (glyphTile & 1);
+            for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
+                unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
+                unsigned int srcPixelsOffset =
+                    512 * (glyphIndex >> 3) + 32 * (glyphIndex & 7) + 256 * (glyphTile >> 1) + 16 * (glyphTile & 1);
 
-				for (unsigned int i = 0; i < 8; i++) {
-					unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;
-					unsigned int destPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
+                for (unsigned int i = 0; i < 8; i++) {
+                    unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;
+                    unsigned int destPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
 
-					dest[destPixelsOffset] = src[srcPixelsOffset + 1];
-					dest[destPixelsOffset + 1] = src[srcPixelsOffset];
+                    dest[destPixelsOffset] = src[srcPixelsOffset + 1];
+                    dest[destPixelsOffset + 1] = src[srcPixelsOffset];
 
-					srcPixelsOffset += 2;
-				}
-			}
-		}
-	}
+                    srcPixelsOffset += 2;
+                }
+            }
+        }
+    }
 }
 
-static void ConvertToFullwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows)
-{
-	for (unsigned int row = 0; row < numRows; row++) {
-		for (unsigned int column = 0; column < 16; column++) {
-			unsigned int glyphIndex = (row * 16) + column;
+static void ConvertToFullwidthJapaneseFont(unsigned char* src, unsigned char* dest, unsigned int numRows) {
+    for (unsigned int row = 0; row < numRows; row++) {
+        for (unsigned int column = 0; column < 16; column++) {
+            unsigned int glyphIndex = (row * 16) + column;
 
-			for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
-				unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
-				unsigned int destPixelsOffset = 512 * (glyphIndex >> 3) + 32 * (glyphIndex & 7) + 256 * (glyphTile >> 1) + 16 * (glyphTile & 1);
+            for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) {
+                unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8);
+                unsigned int destPixelsOffset =
+                    512 * (glyphIndex >> 3) + 32 * (glyphIndex & 7) + 256 * (glyphTile >> 1) + 16 * (glyphTile & 1);
 
-				for (unsigned int i = 0; i < 8; i++) {
-					unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;
-					unsigned int srcPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
+                for (unsigned int i = 0; i < 8; i++) {
+                    unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i;
+                    unsigned int srcPixelsOffset = (pixelsY * 64) + (pixelsX / 4);
 
-					dest[destPixelsOffset] = src[srcPixelsOffset + 1];
-					dest[destPixelsOffset + 1] = src[srcPixelsOffset];
+                    dest[destPixelsOffset] = src[srcPixelsOffset + 1];
+                    dest[destPixelsOffset + 1] = src[srcPixelsOffset];
 
-					destPixelsOffset += 2;
-				}
-			}
-		}
-	}
+                    destPixelsOffset += 2;
+                }
+            }
+        }
+    }
 }
 
-static void SetFontPalette(struct Image *image)
-{
-	image->hasPalette = true;
+static void SetFontPalette(struct Image* image) {
+    image->hasPalette = true;
 
-	image->palette.numColors = 4;
+    image->palette.numColors = 4;
 
-	for (int i = 0; i < image->palette.numColors; i++) {
-		image->palette.colors[i].red = gFontPalette[i][0];
-		image->palette.colors[i].green = gFontPalette[i][1];
-		image->palette.colors[i].blue = gFontPalette[i][2];
-	}
+    for (int i = 0; i < image->palette.numColors; i++) {
+        image->palette.colors[i].red = gFontPalette[i][0];
+        image->palette.colors[i].green = gFontPalette[i][1];
+        image->palette.colors[i].blue = gFontPalette[i][2];
+    }
 
-	image->hasTransparency = false;
+    image->hasTransparency = false;
 }
 
-void ReadLatinFont(char *path, struct Image *image)
-{
-	int fileSize;
-	unsigned char *buffer = ReadWholeFile(path, &fileSize);
+void ReadLatinFont(char* path, struct Image* image) {
+    int fileSize;
+    unsigned char* buffer = ReadWholeFile(path, &fileSize);
 
-	int numGlyphs = fileSize / 64;
+    int numGlyphs = fileSize / 64;
 
-	if (numGlyphs % 16 != 0)
-		FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs);
+    if (numGlyphs % 16 != 0)
+        FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs);
 
-	int numRows = numGlyphs / 16;
+    int numRows = numGlyphs / 16;
 
-	image->width = 256;
-	image->height = numRows * 16;
-	image->bitDepth = 2;
-	image->pixels = malloc(fileSize);
+    image->width = 256;
+    image->height = numRows * 16;
+    image->bitDepth = 2;
+    image->pixels = malloc(fileSize);
 
-	if (image->pixels == NULL)
-		FATAL_ERROR("Failed to allocate memory for font.\n");
+    if (image->pixels == NULL)
+        FATAL_ERROR("Failed to allocate memory for font.\n");
 
-	ConvertFromLatinFont(buffer, image->pixels, numRows);
+    ConvertFromLatinFont(buffer, image->pixels, numRows);
 
-	free(buffer);
+    free(buffer);
 
-	SetFontPalette(image);
+    SetFontPalette(image);
 }
 
-void WriteLatinFont(char *path, struct Image *image)
-{
-	if (image->width != 256)
-		FATAL_ERROR("The width of the font image (%d) is not 256.\n", image->width);
+void WriteLatinFont(char* path, struct Image* image) {
+    if (image->width != 256)
+        FATAL_ERROR("The width of the font image (%d) is not 256.\n", image->width);
 
-	if (image->height % 16 != 0)
-		FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height);
+    if (image->height % 16 != 0)
+        FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height);
 
-	int numRows = image->height / 16;
-	int bufferSize = numRows * 16 * 64;
-	unsigned char *buffer = malloc(bufferSize);
+    int numRows = image->height / 16;
+    int bufferSize = numRows * 16 * 64;
+    unsigned char* buffer = malloc(bufferSize);
 
-	if (buffer == NULL)
-		FATAL_ERROR("Failed to allocate memory for font.\n");
+    if (buffer == NULL)
+        FATAL_ERROR("Failed to allocate memory for font.\n");
 
-	ConvertToLatinFont(image->pixels, buffer, numRows);
+    ConvertToLatinFont(image->pixels, buffer, numRows);
 
-	WriteWholeFile(path, buffer, bufferSize);
+    WriteWholeFile(path, buffer, bufferSize);
 
-	free(buffer);
+    free(buffer);
 }
 
-void ReadHalfwidthJapaneseFont(char *path, struct Image *image)
-{
-	int fileSize;
-	unsigned char *buffer = ReadWholeFile(path, &fileSize);
+void ReadHalfwidthJapaneseFont(char* path, struct Image* image) {
+    int fileSize;
+    unsigned char* buffer = ReadWholeFile(path, &fileSize);
+
+    int glyphSize = 32;
 
-	int glyphSize = 32;
+    if (fileSize % glyphSize != 0)
+        FATAL_ERROR("The file size (%d) is not a multiple of %d.\n", fileSize, glyphSize);
 
-	if (fileSize % glyphSize != 0)
-		FATAL_ERROR("The file size (%d) is not a multiple of %d.\n", fileSize, glyphSize);
+    int numGlyphs = fileSize / glyphSize;
 
-	int numGlyphs = fileSize / glyphSize;
-	
-	if (numGlyphs % 16 != 0)
-		FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs);
+    if (numGlyphs % 16 != 0)
+        FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs);
 
-	int numRows = numGlyphs / 16;
+    int numRows = numGlyphs / 16;
 
-	image->width = 128;
-	image->height = numRows * 16;
-	image->bitDepth = 2;
-	image->pixels = malloc(fileSize);
+    image->width = 128;
+    image->height = numRows * 16;
+    image->bitDepth = 2;
+    image->pixels = malloc(fileSize);
 
-	if (image->pixels == NULL)
-		FATAL_ERROR("Failed to allocate memory for font.\n");
+    if (image->pixels == NULL)
+        FATAL_ERROR("Failed to allocate memory for font.\n");
 
-	ConvertFromHalfwidthJapaneseFont(buffer, image->pixels, numRows);
+    ConvertFromHalfwidthJapaneseFont(buffer, image->pixels, numRows);
 
-	free(buffer);
+    free(buffer);
 
-	SetFontPalette(image);
+    SetFontPalette(image);
 }
 
-void WriteHalfwidthJapaneseFont(char *path, struct Image *image)
-{
-	if (image->width != 128)
-		FATAL_ERROR("The width of the font image (%d) is not 128.\n", image->width);
+void WriteHalfwidthJapaneseFont(char* path, struct Image* image) {
+    if (image->width != 128)
+        FATAL_ERROR("The width of the font image (%d) is not 128.\n", image->width);
 
-	if (image->height % 16 != 0)
-		FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height);
+    if (image->height % 16 != 0)
+        FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height);
 
-	int numRows = image->height / 16;
-	int bufferSize = numRows * 16 * 32;
-	unsigned char *buffer = malloc(bufferSize);
+    int numRows = image->height / 16;
+    int bufferSize = numRows * 16 * 32;
+    unsigned char* buffer = malloc(bufferSize);
 
-	if (buffer == NULL)
-		FATAL_ERROR("Failed to allocate memory for font.\n");
+    if (buffer == NULL)
+        FATAL_ERROR("Failed to allocate memory for font.\n");
 
-	ConvertToHalfwidthJapaneseFont(image->pixels, buffer, numRows);
+    ConvertToHalfwidthJapaneseFont(image->pixels, buffer, numRows);
 
-	WriteWholeFile(path, buffer, bufferSize);
+    WriteWholeFile(path, buffer, bufferSize);
 
-	free(buffer);
+    free(buffer);
 }
 
-void ReadFullwidthJapaneseFont(char *path, struct Image *image)
-{
-	int fileSize;
-	unsigned char *buffer = ReadWholeFile(path, &fileSize);
+void ReadFullwidthJapaneseFont(char* path, struct Image* image) {
+    int fileSize;
+    unsigned char* buffer = ReadWholeFile(path, &fileSize);
 
-	int numGlyphs = fileSize / 64;
+    int numGlyphs = fileSize / 64;
 
-	if (numGlyphs % 16 != 0)
-		FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs);
+    if (numGlyphs % 16 != 0)
+        FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs);
 
-	int numRows = numGlyphs / 16;
+    int numRows = numGlyphs / 16;
 
-	image->width = 256;
-	image->height = numRows * 16;
-	image->bitDepth = 2;
-	image->pixels = malloc(fileSize);
+    image->width = 256;
+    image->height = numRows * 16;
+    image->bitDepth = 2;
+    image->pixels = malloc(fileSize);
 
-	if (image->pixels == NULL)
-		FATAL_ERROR("Failed to allocate memory for font.\n");
+    if (image->pixels == NULL)
+        FATAL_ERROR("Failed to allocate memory for font.\n");
 
-	ConvertFromFullwidthJapaneseFont(buffer, image->pixels, numRows);
+    ConvertFromFullwidthJapaneseFont(buffer, image->pixels, numRows);
 
-	free(buffer);
+    free(buffer);
 
-	SetFontPalette(image);
+    SetFontPalette(image);
 }
 
-void WriteFullwidthJapaneseFont(char *path, struct Image *image)
-{
-	if (image->width != 256)
-		FATAL_ERROR("The width of the font image (%d) is not 256.\n", image->width);
+void WriteFullwidthJapaneseFont(char* path, struct Image* image) {
+    if (image->width != 256)
+        FATAL_ERROR("The width of the font image (%d) is not 256.\n", image->width);
 
-	if (image->height % 16 != 0)
-		FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height);
+    if (image->height % 16 != 0)
+        FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height);
 
-	int numRows = image->height / 16;
-	int bufferSize = numRows * 16 * 64;
-	unsigned char *buffer = malloc(bufferSize);
+    int numRows = image->height / 16;
+    int bufferSize = numRows * 16 * 64;
+    unsigned char* buffer = malloc(bufferSize);
 
-	if (buffer == NULL)
-		FATAL_ERROR("Failed to allocate memory for font.\n");
+    if (buffer == NULL)
+        FATAL_ERROR("Failed to allocate memory for font.\n");
 
-	ConvertToFullwidthJapaneseFont(image->pixels, buffer, numRows);
+    ConvertToFullwidthJapaneseFont(image->pixels, buffer, numRows);
 
-	WriteWholeFile(path, buffer, bufferSize);
+    WriteWholeFile(path, buffer, bufferSize);
 
-	free(buffer);
+    free(buffer);
 }
diff --git a/tools/src/gbagfx/font.h b/tools/src/gbagfx/font.h
index 45086d02..9ff03792 100755..100644
--- a/tools/src/gbagfx/font.h
+++ b/tools/src/gbagfx/font.h
@@ -6,11 +6,11 @@
 #include <stdbool.h>
 #include "gfx.h"
 
-void ReadLatinFont(char *path, struct Image *image);
-void WriteLatinFont(char *path, struct Image *image);
-void ReadHalfwidthJapaneseFont(char *path, struct Image *image);
-void WriteHalfwidthJapaneseFont(char *path, struct Image *image);
-void ReadFullwidthJapaneseFont(char *path, struct Image *image);
-void WriteFullwidthJapaneseFont(char *path, struct Image *image);
+void ReadLatinFont(char* path, struct Image* image);
+void WriteLatinFont(char* path, struct Image* image);
+void ReadHalfwidthJapaneseFont(char* path, struct Image* image);
+void WriteHalfwidthJapaneseFont(char* path, struct Image* image);
+void ReadFullwidthJapaneseFont(char* path, struct Image* image);
+void WriteFullwidthJapaneseFont(char* path, struct Image* image);
 
 #endif // FONT_H
diff --git a/tools/src/gbagfx/gfx.c b/tools/src/gbagfx/gfx.c
index f927deed..f16dd8ac 100755..100644
--- a/tools/src/gbagfx/gfx.c
+++ b/tools/src/gbagfx/gfx.c
@@ -8,337 +8,351 @@
 #include "gfx.h"
 #include "util.h"
 
-#define GET_GBA_PAL_RED(x)   (((x) >>  0) & 0x1F)
-#define GET_GBA_PAL_GREEN(x) (((x) >>  5) & 0x1F)
-#define GET_GBA_PAL_BLUE(x)  (((x) >> 10) & 0x1F)
+#define GET_GBA_PAL_RED(x) (((x) >> 0) & 0x1F)
+#define GET_GBA_PAL_GREEN(x) (((x) >> 5) & 0x1F)
+#define GET_GBA_PAL_BLUE(x) (((x) >> 10) & 0x1F)
 
 #define SET_GBA_PAL(r, g, b) (((b) << 10) | ((g) << 5) | (r))
 
-#define UPCONVERT_BIT_DEPTH(x) (((x) * 255) / 31)
+#define UPCONVERT_BIT_DEPTH(x) (((x)*255) / 31)
 
 #define DOWNCONVERT_BIT_DEPTH(x) ((x) / 8)
 
-static void AdvanceMetatilePosition(int *subTileX, int *subTileY, int *metatileX, int *metatileY, int metatilesWide, int metatileWidth, int metatileHeight)
-{
-	(*subTileX)++;
-	if (*subTileX == metatileWidth) {
-		*subTileX = 0;
-		(*subTileY)++;
-		if (*subTileY == metatileHeight) {
-			*subTileY = 0;
-			(*metatileX)++;
-			if (*metatileX == metatilesWide) {
-				*metatileX = 0;
-				(*metatileY)++;
-			}
-		}
-	}
+static void AdvanceMetatilePosition(int* subTileX, int* subTileY, int* metatileX, int* metatileY, int metatilesWide,
+                                    int metatileWidth, int metatileHeight) {
+    (*subTileX)++;
+    if (*subTileX == metatileWidth) {
+        *subTileX = 0;
+        (*subTileY)++;
+        if (*subTileY == metatileHeight) {
+            *subTileY = 0;
+            (*metatileX)++;
+            if (*metatileX == metatilesWide) {
+                *metatileX = 0;
+                (*metatileY)++;
+            }
+        }
+    }
 }
 
-static void ConvertFromTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
-{
-	int subTileX = 0;
-	int subTileY = 0;
-	int metatileX = 0;
-	int metatileY = 0;
-	int pitch = metatilesWide * metatileWidth;
-
-	for (int i = 0; i < numTiles; i++) {
-		for (int j = 0; j < 8; j++) {
-			int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
-			int destX = metatileX * metatileWidth + subTileX;
-			unsigned char srcPixelOctet = *src++;
-			unsigned char *destPixelOctet = &dest[destY * pitch + destX];
-
-			for (int k = 0; k < 8; k++) {
-				*destPixelOctet <<= 1;
-				*destPixelOctet |= (srcPixelOctet & 1) ^ invertColors;
-				srcPixelOctet >>= 1;
-			}
-		}
-
-		AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
-	}
+static void ConvertFromTiles1Bpp(unsigned char* src, unsigned char* dest, int numTiles, int metatilesWide,
+                                 int metatileWidth, int metatileHeight, bool invertColors) {
+    int subTileX = 0;
+    int subTileY = 0;
+    int metatileX = 0;
+    int metatileY = 0;
+    int pitch = metatilesWide * metatileWidth;
+
+    for (int i = 0; i < numTiles; i++) {
+        for (int j = 0; j < 8; j++) {
+            int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
+            int destX = metatileX * metatileWidth + subTileX;
+            unsigned char srcPixelOctet = *src++;
+            unsigned char* destPixelOctet = &dest[destY * pitch + destX];
+
+            for (int k = 0; k < 8; k++) {
+                *destPixelOctet <<= 1;
+                *destPixelOctet |= (srcPixelOctet & 1) ^ invertColors;
+                srcPixelOctet >>= 1;
+            }
+        }
+
+        AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth,
+                                metatileHeight);
+    }
 }
 
-static void ConvertFromTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
-{
-	int subTileX = 0;
-	int subTileY = 0;
-	int metatileX = 0;
-	int metatileY = 0;
-	int pitch = (metatilesWide * metatileWidth) * 4;
-
-	for (int i = 0; i < numTiles; i++) {
-		for (int j = 0; j < 8; j++) {
-			int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
-
-			for (int k = 0; k < 4; k++) {
-				int destX = (metatileX * metatileWidth + subTileX) * 4 + k;
-				unsigned char srcPixelPair = *src++;
-				unsigned char leftPixel = srcPixelPair & 0xF;
-				unsigned char rightPixel = srcPixelPair >> 4;
-
-				if (invertColors) {
-					leftPixel = 15 - leftPixel;
-					rightPixel = 15 - rightPixel;
-				}
-
-				dest[destY * pitch + destX] = (leftPixel << 4) | rightPixel;
-			}
-		}
-
-		AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
-	}
+static void ConvertFromTiles4Bpp(unsigned char* src, unsigned char* dest, int numTiles, int metatilesWide,
+                                 int metatileWidth, int metatileHeight, bool invertColors) {
+    int subTileX = 0;
+    int subTileY = 0;
+    int metatileX = 0;
+    int metatileY = 0;
+    int pitch = (metatilesWide * metatileWidth) * 4;
+
+    for (int i = 0; i < numTiles; i++) {
+        for (int j = 0; j < 8; j++) {
+            int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
+
+            for (int k = 0; k < 4; k++) {
+                int destX = (metatileX * metatileWidth + subTileX) * 4 + k;
+                unsigned char srcPixelPair = *src++;
+                unsigned char leftPixel = srcPixelPair & 0xF;
+                unsigned char rightPixel = srcPixelPair >> 4;
+
+                if (invertColors) {
+                    leftPixel = 15 - leftPixel;
+                    rightPixel = 15 - rightPixel;
+                }
+
+                dest[destY * pitch + destX] = (leftPixel << 4) | rightPixel;
+            }
+        }
+
+        AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth,
+                                metatileHeight);
+    }
 }
 
-static void ConvertFromTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
-{
-	int subTileX = 0;
-	int subTileY = 0;
-	int metatileX = 0;
-	int metatileY = 0;
-	int pitch = (metatilesWide * metatileWidth) * 8;
+static void ConvertFromTiles8Bpp(unsigned char* src, unsigned char* dest, int numTiles, int metatilesWide,
+                                 int metatileWidth, int metatileHeight, bool invertColors) {
+    int subTileX = 0;
+    int subTileY = 0;
+    int metatileX = 0;
+    int metatileY = 0;
+    int pitch = (metatilesWide * metatileWidth) * 8;
 
-	for (int i = 0; i < numTiles; i++) {
-		for (int j = 0; j < 8; j++) {
-			int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
+    for (int i = 0; i < numTiles; i++) {
+        for (int j = 0; j < 8; j++) {
+            int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
 
-			for (int k = 0; k < 8; k++) {
-				int destX = (metatileX * metatileWidth + subTileX) * 8 + k;
-				unsigned char srcPixel = *src++;
+            for (int k = 0; k < 8; k++) {
+                int destX = (metatileX * metatileWidth + subTileX) * 8 + k;
+                unsigned char srcPixel = *src++;
 
-				if (invertColors)
-					srcPixel = 255 - srcPixel;
+                if (invertColors)
+                    srcPixel = 255 - srcPixel;
 
-				dest[destY * pitch + destX] = srcPixel;
-			}
-		}
+                dest[destY * pitch + destX] = srcPixel;
+            }
+        }
 
-		AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
-	}
+        AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth,
+                                metatileHeight);
+    }
 }
 
-static void ConvertToTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
-{
-	int subTileX = 0;
-	int subTileY = 0;
-	int metatileX = 0;
-	int metatileY = 0;
-	int pitch = metatilesWide * metatileWidth;
-
-	for (int i = 0; i < numTiles; i++) {
-		for (int j = 0; j < 8; j++) {
-			int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
-			int srcX = metatileX * metatileWidth + subTileX;
-			unsigned char srcPixelOctet = src[srcY * pitch + srcX];
-			unsigned char *destPixelOctet = dest++;
-
-			for (int k = 0; k < 8; k++) {
-				*destPixelOctet <<= 1;
-				*destPixelOctet |= (srcPixelOctet & 1) ^ invertColors;
-				srcPixelOctet >>= 1;
-			}
-		}
-
-		AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
-	}
+static void ConvertToTiles1Bpp(unsigned char* src, unsigned char* dest, int numTiles, int metatilesWide,
+                               int metatileWidth, int metatileHeight, bool invertColors) {
+    int subTileX = 0;
+    int subTileY = 0;
+    int metatileX = 0;
+    int metatileY = 0;
+    int pitch = metatilesWide * metatileWidth;
+
+    for (int i = 0; i < numTiles; i++) {
+        for (int j = 0; j < 8; j++) {
+            int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
+            int srcX = metatileX * metatileWidth + subTileX;
+            unsigned char srcPixelOctet = src[srcY * pitch + srcX];
+            unsigned char* destPixelOctet = dest++;
+
+            for (int k = 0; k < 8; k++) {
+                *destPixelOctet <<= 1;
+                *destPixelOctet |= (srcPixelOctet & 1) ^ invertColors;
+                srcPixelOctet >>= 1;
+            }
+        }
+
+        AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth,
+                                metatileHeight);
+    }
 }
 
-static void ConvertToTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
-{
-	int subTileX = 0;
-	int subTileY = 0;
-	int metatileX = 0;
-	int metatileY = 0;
-	int pitch = (metatilesWide * metatileWidth) * 4;
-
-	for (int i = 0; i < numTiles; i++) {
-		for (int j = 0; j < 8; j++) {
-			int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
-
-			for (int k = 0; k < 4; k++) {
-				int srcX = (metatileX * metatileWidth + subTileX) * 4 + k;
-				unsigned char srcPixelPair = src[srcY * pitch + srcX];
-				unsigned char leftPixel = srcPixelPair >> 4;
-				unsigned char rightPixel = srcPixelPair & 0xF;
-
-				if (invertColors) {
-					leftPixel = 15 - leftPixel;
-					rightPixel = 15 - rightPixel;
-				}
-
-				*dest++ = (rightPixel << 4) | leftPixel;
-			}
-		}
-
-		AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
-	}
+static void ConvertToTiles4Bpp(unsigned char* src, unsigned char* dest, int numTiles, int metatilesWide,
+                               int metatileWidth, int metatileHeight, bool invertColors) {
+    int subTileX = 0;
+    int subTileY = 0;
+    int metatileX = 0;
+    int metatileY = 0;
+    int pitch = (metatilesWide * metatileWidth) * 4;
+
+    for (int i = 0; i < numTiles; i++) {
+        for (int j = 0; j < 8; j++) {
+            int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
+
+            for (int k = 0; k < 4; k++) {
+                int srcX = (metatileX * metatileWidth + subTileX) * 4 + k;
+                unsigned char srcPixelPair = src[srcY * pitch + srcX];
+                unsigned char leftPixel = srcPixelPair >> 4;
+                unsigned char rightPixel = srcPixelPair & 0xF;
+
+                if (invertColors) {
+                    leftPixel = 15 - leftPixel;
+                    rightPixel = 15 - rightPixel;
+                }
+
+                *dest++ = (rightPixel << 4) | leftPixel;
+            }
+        }
+
+        AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth,
+                                metatileHeight);
+    }
 }
 
-static void ConvertToTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
-{
-	int subTileX = 0;
-	int subTileY = 0;
-	int metatileX = 0;
-	int metatileY = 0;
-	int pitch = (metatilesWide * metatileWidth) * 8;
+static void ConvertToTiles8Bpp(unsigned char* src, unsigned char* dest, int numTiles, int metatilesWide,
+                               int metatileWidth, int metatileHeight, bool invertColors) {
+    int subTileX = 0;
+    int subTileY = 0;
+    int metatileX = 0;
+    int metatileY = 0;
+    int pitch = (metatilesWide * metatileWidth) * 8;
 
-	for (int i = 0; i < numTiles; i++) {
-		for (int j = 0; j < 8; j++) {
-			int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
+    for (int i = 0; i < numTiles; i++) {
+        for (int j = 0; j < 8; j++) {
+            int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
 
-			for (int k = 0; k < 8; k++) {
-				int srcX = (metatileX * metatileWidth + subTileX) * 8 + k;
-				unsigned char srcPixel = src[srcY * pitch + srcX];
+            for (int k = 0; k < 8; k++) {
+                int srcX = (metatileX * metatileWidth + subTileX) * 8 + k;
+                unsigned char srcPixel = src[srcY * pitch + srcX];
 
-				if (invertColors)
-					srcPixel = 255 - srcPixel;
+                if (invertColors)
+                    srcPixel = 255 - srcPixel;
 
-				*dest++ = srcPixel;
-			}
-		}
+                *dest++ = srcPixel;
+            }
+        }
 
-		AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
-	}
+        AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth,
+                                metatileHeight);
+    }
 }
 
-void ReadImage(char *path, int tilesWidth, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors)
-{
-	int tileSize = bitDepth * 8;
+void ReadImage(char* path, int tilesWidth, int bitDepth, int metatileWidth, int metatileHeight, struct Image* image,
+               bool invertColors) {
+    int tileSize = bitDepth * 8;
 
-	int fileSize;
-	unsigned char *buffer = ReadWholeFile(path, &fileSize);
+    int fileSize;
+    unsigned char* buffer = ReadWholeFile(path, &fileSize);
 
-	int numTiles = fileSize / tileSize;
+    int numTiles = fileSize / tileSize;
 
-	int tilesHeight = (numTiles + tilesWidth - 1) / tilesWidth;
+    int tilesHeight = (numTiles + tilesWidth - 1) / tilesWidth;
 
-	if (tilesWidth % metatileWidth != 0)
-		FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified metatile width (%d)", tilesWidth, metatileWidth);
+    if (tilesWidth % metatileWidth != 0)
+        FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified metatile width (%d)", tilesWidth,
+                    metatileWidth);
 
-	if (tilesHeight % metatileHeight != 0)
-		FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified metatile height (%d)", tilesHeight, metatileHeight);
+    if (tilesHeight % metatileHeight != 0)
+        FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified metatile height (%d)", tilesHeight,
+                    metatileHeight);
 
-	image->width = tilesWidth * 8;
-	image->height = tilesHeight * 8;
-	image->bitDepth = bitDepth;
-	image->pixels = calloc(tilesWidth * tilesHeight, tileSize);
+    image->width = tilesWidth * 8;
+    image->height = tilesHeight * 8;
+    image->bitDepth = bitDepth;
+    image->pixels = calloc(tilesWidth * tilesHeight, tileSize);
 
-	if (image->pixels == NULL)
-		FATAL_ERROR("Failed to allocate memory for pixels.\n");
+    if (image->pixels == NULL)
+        FATAL_ERROR("Failed to allocate memory for pixels.\n");
 
-	int metatilesWide = tilesWidth / metatileWidth;
+    int metatilesWide = tilesWidth / metatileWidth;
 
-	switch (bitDepth) {
-	case 1:
-		ConvertFromTiles1Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
-		break;
-	case 4:
-		ConvertFromTiles4Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
-		break;
-	case 8:
-		ConvertFromTiles8Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
-		break;
-	}
+    switch (bitDepth) {
+        case 1:
+            ConvertFromTiles1Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight,
+                                 invertColors);
+            break;
+        case 4:
+            ConvertFromTiles4Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight,
+                                 invertColors);
+            break;
+        case 8:
+            ConvertFromTiles8Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight,
+                                 invertColors);
+            break;
+    }
 
-	free(buffer);
+    free(buffer);
 }
 
-void WriteImage(char *path, int numTiles, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors)
-{
-	int tileSize = bitDepth * 8;
+void WriteImage(char* path, int numTiles, int bitDepth, int metatileWidth, int metatileHeight, struct Image* image,
+                bool invertColors) {
+    int tileSize = bitDepth * 8;
 
-	if (image->width % 8 != 0)
-		FATAL_ERROR("The width in pixels (%d) isn't a multiple of 8.\n", image->width);
+    if (image->width % 8 != 0)
+        FATAL_ERROR("The width in pixels (%d) isn't a multiple of 8.\n", image->width);
 
-	if (image->height % 8 != 0)
-		FATAL_ERROR("The height in pixels (%d) isn't a multiple of 8.\n", image->height);
+    if (image->height % 8 != 0)
+        FATAL_ERROR("The height in pixels (%d) isn't a multiple of 8.\n", image->height);
 
-	int tilesWidth = image->width / 8;
-	int tilesHeight = image->height / 8;
+    int tilesWidth = image->width / 8;
+    int tilesHeight = image->height / 8;
 
-	if (tilesWidth % metatileWidth != 0)
-		FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified metatile width (%d)", tilesWidth, metatileWidth);
+    if (tilesWidth % metatileWidth != 0)
+        FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified metatile width (%d)", tilesWidth,
+                    metatileWidth);
 
-	if (tilesHeight % metatileHeight != 0)
-		FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified metatile height (%d)", tilesHeight, metatileHeight);
+    if (tilesHeight % metatileHeight != 0)
+        FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified metatile height (%d)", tilesHeight,
+                    metatileHeight);
 
-	int maxNumTiles = tilesWidth * tilesHeight;
+    int maxNumTiles = tilesWidth * tilesHeight;
 
-	if (numTiles == 0)
-		numTiles = maxNumTiles;
-	else if (numTiles > maxNumTiles)
-		FATAL_ERROR("The specified number of tiles (%d) is greater than the maximum possible value (%d).\n", numTiles, maxNumTiles);
+    if (numTiles == 0)
+        numTiles = maxNumTiles;
+    else if (numTiles > maxNumTiles)
+        FATAL_ERROR("The specified number of tiles (%d) is greater than the maximum possible value (%d).\n", numTiles,
+                    maxNumTiles);
 
-	int bufferSize = numTiles * tileSize;
-	unsigned char *buffer = malloc(bufferSize);
+    int bufferSize = numTiles * tileSize;
+    unsigned char* buffer = malloc(bufferSize);
 
-	if (buffer == NULL)
-		FATAL_ERROR("Failed to allocate memory for pixels.\n");
+    if (buffer == NULL)
+        FATAL_ERROR("Failed to allocate memory for pixels.\n");
 
-	int metatilesWide = tilesWidth / metatileWidth;
+    int metatilesWide = tilesWidth / metatileWidth;
 
-	switch (bitDepth) {
-	case 1:
-		ConvertToTiles1Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
-		break;
-	case 4:
-		ConvertToTiles4Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
-		break;
-	case 8:
-		ConvertToTiles8Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
-		break;
-	}
+    switch (bitDepth) {
+        case 1:
+            ConvertToTiles1Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight,
+                               invertColors);
+            break;
+        case 4:
+            ConvertToTiles4Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight,
+                               invertColors);
+            break;
+        case 8:
+            ConvertToTiles8Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight,
+                               invertColors);
+            break;
+    }
 
-	WriteWholeFile(path, buffer, bufferSize);
+    WriteWholeFile(path, buffer, bufferSize);
 
-	free(buffer);
+    free(buffer);
 }
 
-void FreeImage(struct Image *image)
-{
-	free(image->pixels);
-	image->pixels = NULL;
+void FreeImage(struct Image* image) {
+    free(image->pixels);
+    image->pixels = NULL;
 }
 
-void ReadGbaPalette(char *path, struct Palette *palette)
-{
-	int fileSize;
-	unsigned char *data = ReadWholeFile(path, &fileSize);
+void ReadGbaPalette(char* path, struct Palette* palette) {
+    int fileSize;
+    unsigned char* data = ReadWholeFile(path, &fileSize);
 
-	if (fileSize % 2 != 0)
-		FATAL_ERROR("The file size (%d) is not a multiple of 2.\n", fileSize);
+    if (fileSize % 2 != 0)
+        FATAL_ERROR("The file size (%d) is not a multiple of 2.\n", fileSize);
 
-	palette->numColors = fileSize / 2;
+    palette->numColors = fileSize / 2;
 
-	for (int i = 0; i < palette->numColors; i++) {
-		uint16_t paletteEntry = (data[i * 2 + 1] << 8) | data[i * 2];
-		palette->colors[i].red = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_RED(paletteEntry));
-		palette->colors[i].green = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_GREEN(paletteEntry));
-		palette->colors[i].blue = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_BLUE(paletteEntry));
-	}
+    for (int i = 0; i < palette->numColors; i++) {
+        uint16_t paletteEntry = (data[i * 2 + 1] << 8) | data[i * 2];
+        palette->colors[i].red = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_RED(paletteEntry));
+        palette->colors[i].green = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_GREEN(paletteEntry));
+        palette->colors[i].blue = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_BLUE(paletteEntry));
+    }
 
-	free(data);
+    free(data);
 }
 
-void WriteGbaPalette(char *path, struct Palette *palette)
-{
-	FILE *fp = fopen(path, "wb");
+void WriteGbaPalette(char* path, struct Palette* palette) {
+    FILE* fp = fopen(path, "wb");
 
-	if (fp == NULL)
-		FATAL_ERROR("Failed to open \"%s\" for writing.\n", path);
+    if (fp == NULL)
+        FATAL_ERROR("Failed to open \"%s\" for writing.\n", path);
 
-	for (int i = 0; i < palette->numColors; i++) {
-		unsigned char red = DOWNCONVERT_BIT_DEPTH(palette->colors[i].red);
-		unsigned char green = DOWNCONVERT_BIT_DEPTH(palette->colors[i].green);
-		unsigned char blue = DOWNCONVERT_BIT_DEPTH(palette->colors[i].blue);
+    for (int i = 0; i < palette->numColors; i++) {
+        unsigned char red = DOWNCONVERT_BIT_DEPTH(palette->colors[i].red);
+        unsigned char green = DOWNCONVERT_BIT_DEPTH(palette->colors[i].green);
+        unsigned char blue = DOWNCONVERT_BIT_DEPTH(palette->colors[i].blue);
 
-		uint16_t paletteEntry = SET_GBA_PAL(red, green, blue);
+        uint16_t paletteEntry = SET_GBA_PAL(red, green, blue);
 
-		fputc(paletteEntry & 0xFF, fp);
-		fputc(paletteEntry >> 8, fp);
-	}
+        fputc(paletteEntry & 0xFF, fp);
+        fputc(paletteEntry >> 8, fp);
+    }
 
-	fclose(fp);
+    fclose(fp);
 }
diff --git a/tools/src/gbagfx/gfx.h b/tools/src/gbagfx/gfx.h
index 5355ced8..6b3aff3a 100755..100644
--- a/tools/src/gbagfx/gfx.h
+++ b/tools/src/gbagfx/gfx.h
@@ -7,30 +7,32 @@
 #include <stdbool.h>
 
 struct Color {
-	unsigned char red;
-	unsigned char green;
-	unsigned char blue;
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
 };
 
 struct Palette {
-	struct Color colors[256];
-	int numColors;
+    struct Color colors[256];
+    int numColors;
 };
 
 struct Image {
-	int width;
-	int height;
-	int bitDepth;
-	unsigned char *pixels;
-	bool hasPalette;
-	struct Palette palette;
-	bool hasTransparency;
+    int width;
+    int height;
+    int bitDepth;
+    unsigned char* pixels;
+    bool hasPalette;
+    struct Palette palette;
+    bool hasTransparency;
 };
 
-void ReadImage(char *path, int tilesWidth, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors);
-void WriteImage(char *path, int numTiles, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors);
-void FreeImage(struct Image *image);
-void ReadGbaPalette(char *path, struct Palette *palette);
-void WriteGbaPalette(char *path, struct Palette *palette);
+void ReadImage(char* path, int tilesWidth, int bitDepth, int metatileWidth, int metatileHeight, struct Image* image,
+               bool invertColors);
+void WriteImage(char* path, int numTiles, int bitDepth, int metatileWidth, int metatileHeight, struct Image* image,
+                bool invertColors);
+void FreeImage(struct Image* image);
+void ReadGbaPalette(char* path, struct Palette* palette);
+void WriteGbaPalette(char* path, struct Palette* palette);
 
 #endif // GFX_H
diff --git a/tools/src/gbagfx/global.h b/tools/src/gbagfx/global.h
index 65dd351d..b6fea5a0 100755..100644
--- a/tools/src/gbagfx/global.h
+++ b/tools/src/gbagfx/global.h
@@ -8,21 +8,21 @@
 
 #ifdef _MSC_VER
 
-#define FATAL_ERROR(format, ...)          \
-do {                                      \
-    fprintf(stderr, format, __VA_ARGS__); \
-    exit(1);                              \
-} while (0)
+#define FATAL_ERROR(format, ...)              \
+    do {                                      \
+        fprintf(stderr, format, __VA_ARGS__); \
+        exit(1);                              \
+    } while (0)
 
 #define UNUSED
 
 #else
 
-#define FATAL_ERROR(format, ...)            \
-do {                                        \
-    fprintf(stderr, format, ##__VA_ARGS__); \
-    exit(1);                                \
-} while (0)
+#define FATAL_ERROR(format, ...)                \
+    do {                                        \
+        fprintf(stderr, format, ##__VA_ARGS__); \
+        exit(1);                                \
+    } while (0)
 
 #define UNUSED __attribute__((__unused__))
 
diff --git a/tools/src/gbagfx/huff.c b/tools/src/gbagfx/huff.c
index 143ed79b..f52a7d2d 100755..100644
--- a/tools/src/gbagfx/huff.c
+++ b/tools/src/gbagfx/huff.c
@@ -6,94 +6,94 @@
 #include "global.h"
 #include "huff.h"
 
-static int cmp_tree(const void * a0, const void * b0) {
-    return ((struct HuffData *)a0)->value - ((struct HuffData *)b0)->value;
+static int cmp_tree(const void* a0, const void* b0) {
+    return ((struct HuffData*)a0)->value - ((struct HuffData*)b0)->value;
 }
 
-typedef int (*cmpfun)(const void *, const void *);
+typedef int (*cmpfun)(const void*, const void*);
 
-int msort_r(void * data, size_t count, size_t size, cmpfun cmp, void * buffer) {
+int msort_r(void* data, size_t count, size_t size, cmpfun cmp, void* buffer) {
     /*
      * Out-of-place mergesort (stable sort)
      * Returns 1 on success, 0 on failure
      */
-    void * leftPtr;
-    void * rightPtr;
-    void * leftEnd;
-    void * rightEnd;
+    void* leftPtr;
+    void* rightPtr;
+    void* leftEnd;
+    void* rightEnd;
     int i;
 
     switch (count) {
-    case 0:
-        // Should never be here
-        return 0;
-
-    case 1:
-        // Nothing to do here
-        break;
-
-    case 2:
-        // Swap the two entries if the right one compares higher.
-        if (cmp(data, data + size) > 0) {
-            memcpy(buffer, data, size);
-            memcpy(data, data + size, size);
-            memcpy(data + size, buffer, size);
-        }
-        break;
-    default:
-        // Merge sort out-of-place.
-        leftPtr = data;
-        leftEnd = rightPtr = data + count / 2 * size;
-        rightEnd = data + count * size;
-
-        // Sort the left half
-        if (!msort_r(leftPtr, count / 2, size, cmp, buffer))
+        case 0:
+            // Should never be here
             return 0;
 
-        // Sort the right half
-        if (!msort_r(rightPtr, count / 2 + (count & 1), size, cmp, buffer))
-            return 0;
+        case 1:
+            // Nothing to do here
+            break;
 
-        // Merge the sorted halves out of place
-        i = 0;
-        do {
-            if (cmp(leftPtr, rightPtr) <= 0) {
-                memcpy(buffer + i * size, leftPtr, size);
-                leftPtr += size;
-            } else {
-                memcpy(buffer + i * size, rightPtr, size);
-                rightPtr += size;
+        case 2:
+            // Swap the two entries if the right one compares higher.
+            if (cmp(data, data + size) > 0) {
+                memcpy(buffer, data, size);
+                memcpy(data, data + size, size);
+                memcpy(data + size, buffer, size);
             }
+            break;
+        default:
+            // Merge sort out-of-place.
+            leftPtr = data;
+            leftEnd = rightPtr = data + count / 2 * size;
+            rightEnd = data + count * size;
+
+            // Sort the left half
+            if (!msort_r(leftPtr, count / 2, size, cmp, buffer))
+                return 0;
+
+            // Sort the right half
+            if (!msort_r(rightPtr, count / 2 + (count & 1), size, cmp, buffer))
+                return 0;
+
+            // Merge the sorted halves out of place
+            i = 0;
+            do {
+                if (cmp(leftPtr, rightPtr) <= 0) {
+                    memcpy(buffer + i * size, leftPtr, size);
+                    leftPtr += size;
+                } else {
+                    memcpy(buffer + i * size, rightPtr, size);
+                    rightPtr += size;
+                }
 
-        } while (++i < count && leftPtr < leftEnd && rightPtr < rightEnd);
+            } while (++i < count && leftPtr < leftEnd && rightPtr < rightEnd);
 
-        // Copy the remainder
-        if (i < count) {
-            if (leftPtr < leftEnd) {
-                memcpy(buffer + i * size, leftPtr, leftEnd - leftPtr);
-            }
-            else {
-                memcpy(buffer + i * size, rightPtr, rightEnd - rightPtr);
+            // Copy the remainder
+            if (i < count) {
+                if (leftPtr < leftEnd) {
+                    memcpy(buffer + i * size, leftPtr, leftEnd - leftPtr);
+                } else {
+                    memcpy(buffer + i * size, rightPtr, rightEnd - rightPtr);
+                }
             }
-        }
 
-        // Copy the merged data back
-        memcpy(data, buffer, count * size);
-        break;
+            // Copy the merged data back
+            memcpy(data, buffer, count * size);
+            break;
     }
 
     return 1;
 }
 
-int msort(void * data, size_t count, size_t size, cmpfun cmp) {
-    void * buffer = malloc(count * size);
-    if (buffer == NULL) return 0;
+int msort(void* data, size_t count, size_t size, cmpfun cmp) {
+    void* buffer = malloc(count * size);
+    if (buffer == NULL)
+        return 0;
     int result = msort_r(data, count, size, cmp, buffer);
     free(buffer);
     return result;
 }
 
-static void write_tree(unsigned char * dest, HuffNode_t * tree, int nitems, struct BitEncoding * encoding) {
+static void write_tree(unsigned char* dest, HuffNode_t* tree, int nitems, struct BitEncoding* encoding) {
     /*
      * The example used to guide this function encodes the tree in a
      * breadth-first manner.  We attempt to emulate that here.
@@ -102,7 +102,7 @@ static void write_tree(unsigned char * dest, HuffNode_t * tree, int nitems, stru
     int i, j, k;
 
     // There are (2 * nitems - 1) nodes in the binary tree.  Allocate that.
-    HuffNode_t * traversal = calloc(2 * nitems - 1, sizeof(HuffNode_t));
+    HuffNode_t* traversal = calloc(2 * nitems - 1, sizeof(HuffNode_t));
     if (traversal == NULL)
         FATAL_ERROR("Fatal error while compressing Huff file.\n");
 
@@ -117,8 +117,8 @@ static void write_tree(unsigned char * dest, HuffNode_t * tree, int nitems, stru
             // The index of the path is used to encode the path itself.
             // Start from the most significant relevant bit and work our way down.
             // Keep track of the current and previous nodes.
-            HuffNode_t * currNode = traversal;
-            HuffNode_t * parent = NULL;
+            HuffNode_t* currNode = traversal;
+            HuffNode_t* parent = NULL;
             for (k = 0; k < depth; k++) {
                 if (currNode->header.isLeaf)
                     break;
@@ -159,7 +159,7 @@ static void write_tree(unsigned char * dest, HuffNode_t * tree, int nitems, stru
 
     // Encode each node in the tree.
     for (i = 0; i < 2 * nitems - 1; i++) {
-        HuffNode_t * currNode = traversal + i;
+        HuffNode_t* currNode = traversal + i;
         if (currNode->header.isLeaf) {
             dest[5 + i] = traversal[i].leaf.key;
         } else {
@@ -174,7 +174,7 @@ static void write_tree(unsigned char * dest, HuffNode_t * tree, int nitems, stru
     free(traversal);
 }
 
-static inline void write_32_le(unsigned char * dest, int * destPos, uint32_t * buff, int * buffPos) {
+static inline void write_32_le(unsigned char* dest, int* destPos, uint32_t* buff, int* buffPos) {
     dest[*destPos] = *buff;
     dest[*destPos + 1] = *buff >> 8;
     dest[*destPos + 2] = *buff >> 16;
@@ -184,7 +184,7 @@ static inline void write_32_le(unsigned char * dest, int * destPos, uint32_t * b
     *buffPos = 0;
 }
 
-static inline void read_32_le(unsigned char * src, int * srcPos, uint32_t * buff) {
+static inline void read_32_le(unsigned char* src, int* srcPos, uint32_t* buff) {
     uint32_t tmp = src[*srcPos];
     tmp |= src[*srcPos + 1] << 8;
     tmp |= src[*srcPos + 2] << 16;
@@ -193,7 +193,8 @@ static inline void read_32_le(unsigned char * src, int * srcPos, uint32_t * buff
     *buff = tmp;
 }
 
-static void write_bits(unsigned char * dest, int * destPos, struct BitEncoding * encoding, int value, uint32_t * buff, int * buffBits) {
+static void write_bits(unsigned char* dest, int* destPos, struct BitEncoding* encoding, int value, uint32_t* buff,
+                       int* buffBits) {
     int nbits = encoding[value].nbits;
     uint32_t bitstring = encoding[value].bitstring;
 
@@ -218,23 +219,23 @@ MAIN COMPRESSION/DECOMPRESSION ROUTINES
 =======================================
  */
 
-unsigned char * HuffCompress(unsigned char * src, int srcSize, int * compressedSize_p, int bitDepth) {
+unsigned char* HuffCompress(unsigned char* src, int srcSize, int* compressedSize_p, int bitDepth) {
     if (srcSize <= 0)
         goto fail;
 
     int worstCaseDestSize = 4 + (2 << bitDepth) + srcSize * 3;
 
-    unsigned char *dest = malloc(worstCaseDestSize);
+    unsigned char* dest = malloc(worstCaseDestSize);
     if (dest == NULL)
         goto fail;
 
     int nitems = 1 << bitDepth;
 
-    HuffNode_t * freqs = calloc(nitems, sizeof(HuffNode_t));
+    HuffNode_t* freqs = calloc(nitems, sizeof(HuffNode_t));
     if (freqs == NULL)
         goto fail;
 
-    struct BitEncoding * encoding = calloc(nitems, sizeof(struct BitEncoding));
+    struct BitEncoding* encoding = calloc(nitems, sizeof(struct BitEncoding));
     if (encoding == NULL)
         goto fail;
 
@@ -281,16 +282,16 @@ unsigned char * HuffCompress(unsigned char * src, int srcSize, int * compressedS
             goto fail;
     }
 
-    HuffNode_t * tree = calloc(nitems * 2 - 1, sizeof(HuffNode_t));
+    HuffNode_t* tree = calloc(nitems * 2 - 1, sizeof(HuffNode_t));
     if (tree == NULL)
         goto fail;
 
     // Iteratively collapse the two least frequent nodes.
-    HuffNode_t * endptr = freqs + nitems - 2;
+    HuffNode_t* endptr = freqs + nitems - 2;
 
     for (int i = 0; i < nitems - 1; i++) {
-        HuffNode_t * left = freqs;
-        HuffNode_t * right = freqs + 1;
+        HuffNode_t* left = freqs;
+        HuffNode_t* right = freqs + 1;
         tree[i * 2] = *right;
         tree[i * 2 + 1] = *left;
         for (int j = 0; j < nitems - i - 2; j++)
@@ -342,7 +343,7 @@ fail:
     FATAL_ERROR("Fatal error while compressing Huff file.\n");
 }
 
-unsigned char * HuffDecompress(unsigned char * src, int srcSize, int * uncompressedSize_p) {
+unsigned char* HuffDecompress(unsigned char* src, int srcSize, int* uncompressedSize_p) {
     if (srcSize < 4)
         goto fail;
 
@@ -352,7 +353,7 @@ unsigned char * HuffDecompress(unsigned char * src, int srcSize, int * uncompres
 
     int destSize = (src[3] << 16) | (src[2] << 8) | src[1];
 
-    unsigned char *dest = malloc(destSize);
+    unsigned char* dest = malloc(destSize);
 
     if (dest == NULL)
         goto fail;
@@ -365,8 +366,7 @@ unsigned char * HuffDecompress(unsigned char * src, int srcSize, int * uncompres
     uint32_t destTmp = 0;
     uint32_t window;
 
-    for (;;)
-    {
+    for (;;) {
         if (srcPos >= srcSize)
             goto fail;
         read_32_le(src, &srcPos, &window);
diff --git a/tools/src/gbagfx/huff.h b/tools/src/gbagfx/huff.h
index 6002fe95..354cf7de 100755..100644
--- a/tools/src/gbagfx/huff.h
+++ b/tools/src/gbagfx/huff.h
@@ -4,8 +4,8 @@
 union HuffNode;
 
 struct HuffData {
-    unsigned value:31;
-    unsigned isLeaf:1;
+    unsigned value : 31;
+    unsigned isLeaf : 1;
 };
 
 struct HuffLeaf {
@@ -15,8 +15,8 @@ struct HuffLeaf {
 
 struct HuffBranch {
     struct HuffData header;
-    union HuffNode * left;
-    union HuffNode * right;
+    union HuffNode* left;
+    union HuffNode* right;
 };
 
 union HuffNode {
@@ -28,11 +28,11 @@ union HuffNode {
 typedef union HuffNode HuffNode_t;
 
 struct BitEncoding {
-    unsigned long long nbits:6;
-    unsigned long long bitstring:58;
+    unsigned long long nbits : 6;
+    unsigned long long bitstring : 58;
 };
 
-unsigned char * HuffCompress(unsigned char * buffer, int srcSize, int * compressedSize_p, int bitDepth);
-unsigned char * HuffDecompress(unsigned char * buffer, int srcSize, int * uncompressedSize_p);
+unsigned char* HuffCompress(unsigned char* buffer, int srcSize, int* compressedSize_p, int bitDepth);
+unsigned char* HuffDecompress(unsigned char* buffer, int srcSize, int* uncompressedSize_p);
 
-#endif //HUFF_H
+#endif // HUFF_H
diff --git a/tools/src/gbagfx/jasc_pal.c b/tools/src/gbagfx/jasc_pal.c
index e5ba9c3c..afaf8248 100755..100644
--- a/tools/src/gbagfx/jasc_pal.c
+++ b/tools/src/gbagfx/jasc_pal.c
@@ -24,17 +24,14 @@
 
 #define MAX_LINE_LENGTH 11
 
-void ReadJascPaletteLine(FILE *fp, char *line)
-{
+void ReadJascPaletteLine(FILE* fp, char* line) {
     int c;
     int length = 0;
 
-    for (;;)
-    {
+    for (;;) {
         c = fgetc(fp);
 
-        if (c == '\r')
-        {
+        if (c == '\r') {
             c = fgetc(fp);
 
             if (c != '\n')
@@ -54,8 +51,7 @@ void ReadJascPaletteLine(FILE *fp, char *line)
         if (c == 0)
             FATAL_ERROR("NUL character in file.\n");
 
-        if (length == MAX_LINE_LENGTH)
-        {
+        if (length == MAX_LINE_LENGTH) {
             line[length] = 0;
             FATAL_ERROR("The line \"%s\" is too long.\n", line);
         }
@@ -64,11 +60,10 @@ void ReadJascPaletteLine(FILE *fp, char *line)
     }
 }
 
-void ReadJascPalette(char *path, struct Palette *palette)
-{
+void ReadJascPalette(char* path, struct Palette* palette) {
     char line[MAX_LINE_LENGTH + 1];
 
-    FILE *fp = fopen(path, "rb");
+    FILE* fp = fopen(path, "rb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open JASC-PAL file \"%s\" for reading.\n", path);
@@ -89,14 +84,14 @@ void ReadJascPalette(char *path, struct Palette *palette)
         FATAL_ERROR("Failed to parse number of colors.\n");
 
     if (palette->numColors < 1 || palette->numColors > 256)
-        FATAL_ERROR("%d is an invalid number of colors. The number of colors must be in the range [1, 256].\n", palette->numColors);
+        FATAL_ERROR("%d is an invalid number of colors. The number of colors must be in the range [1, 256].\n",
+                    palette->numColors);
 
-    for (int i = 0; i < palette->numColors; i++)
-    {
+    for (int i = 0; i < palette->numColors; i++) {
         ReadJascPaletteLine(fp, line);
 
-        char *s = line;
-        char *end;
+        char* s = line;
+        char* end;
 
         int red;
         int green;
@@ -154,17 +149,15 @@ void ReadJascPalette(char *path, struct Palette *palette)
     fclose(fp);
 }
 
-void WriteJascPalette(char *path, struct Palette *palette)
-{
-    FILE *fp = fopen(path, "wb");
+void WriteJascPalette(char* path, struct Palette* palette) {
+    FILE* fp = fopen(path, "wb");
 
     fputs("JASC-PAL\r\n", fp);
     fputs("0100\r\n", fp);
     fprintf(fp, "%d\r\n", palette->numColors);
 
-    for (int i = 0; i < palette->numColors; i++)
-    {
-        struct Color *color = &palette->colors[i];
+    for (int i = 0; i < palette->numColors; i++) {
+        struct Color* color = &palette->colors[i];
         fprintf(fp, "%d %d %d\r\n", color->red, color->green, color->blue);
     }
 
diff --git a/tools/src/gbagfx/jasc_pal.h b/tools/src/gbagfx/jasc_pal.h
index b60b31fc..9a2eea80 100755..100644
--- a/tools/src/gbagfx/jasc_pal.h
+++ b/tools/src/gbagfx/jasc_pal.h
@@ -3,7 +3,7 @@
 #ifndef JASC_PAL_H
 #define JASC_PAL_H
 
-void ReadJascPalette(char *path, struct Palette *palette);
-void WriteJascPalette(char *path, struct Palette *palette);
+void ReadJascPalette(char* path, struct Palette* palette);
+void WriteJascPalette(char* path, struct Palette* palette);
 
 #endif // JASC_PAL_H
diff --git a/tools/src/gbagfx/lz.c b/tools/src/gbagfx/lz.c
index 97434ce5..97168917 100755..100644
--- a/tools/src/gbagfx/lz.c
+++ b/tools/src/gbagfx/lz.c
@@ -5,149 +5,146 @@
 #include "global.h"
 #include "lz.h"
 
-unsigned char *LZDecompress(unsigned char *src, int srcSize, int *uncompressedSize)
-{
-	if (srcSize < 4)
-		goto fail;
+unsigned char* LZDecompress(unsigned char* src, int srcSize, int* uncompressedSize) {
+    if (srcSize < 4)
+        goto fail;
 
-	int destSize = (src[3] << 16) | (src[2] << 8) | src[1];
+    int destSize = (src[3] << 16) | (src[2] << 8) | src[1];
 
-	unsigned char *dest = malloc(destSize);
+    unsigned char* dest = malloc(destSize);
 
-	if (dest == NULL)
-		goto fail;
+    if (dest == NULL)
+        goto fail;
 
-	int srcPos = 4;
-	int destPos = 0;
+    int srcPos = 4;
+    int destPos = 0;
 
-	for (;;) {
-		if (srcPos >= srcSize)
-			goto fail;
+    for (;;) {
+        if (srcPos >= srcSize)
+            goto fail;
 
-		unsigned char flags = src[srcPos++];
+        unsigned char flags = src[srcPos++];
 
-		for (int i = 0; i < 8; i++) {
-			if (flags & 0x80) {
-				if (srcPos + 1 >= srcSize)
-					goto fail;
+        for (int i = 0; i < 8; i++) {
+            if (flags & 0x80) {
+                if (srcPos + 1 >= srcSize)
+                    goto fail;
 
-				int blockSize = (src[srcPos] >> 4) + 3;
-				int blockDistance = (((src[srcPos] & 0xF) << 8) | src[srcPos + 1]) + 1;
+                int blockSize = (src[srcPos] >> 4) + 3;
+                int blockDistance = (((src[srcPos] & 0xF) << 8) | src[srcPos + 1]) + 1;
 
-				srcPos += 2;
+                srcPos += 2;
 
-				int blockPos = destPos - blockDistance;
+                int blockPos = destPos - blockDistance;
 
-				// Some Ruby/Sapphire tilesets overflow.
-				if (destPos + blockSize > destSize) {
-					blockSize = destSize - destPos;
-					fprintf(stderr, "Destination buffer overflow.\n");
-				}
+                // Some Ruby/Sapphire tilesets overflow.
+                if (destPos + blockSize > destSize) {
+                    blockSize = destSize - destPos;
+                    fprintf(stderr, "Destination buffer overflow.\n");
+                }
 
-				if (blockPos < 0)
-					goto fail;
+                if (blockPos < 0)
+                    goto fail;
 
-				for (int j = 0; j < blockSize; j++)
-					dest[destPos++] = dest[blockPos + j];
-			} else {
-				if (srcPos >= srcSize || destPos >= destSize)
-					goto fail;
+                for (int j = 0; j < blockSize; j++)
+                    dest[destPos++] = dest[blockPos + j];
+            } else {
+                if (srcPos >= srcSize || destPos >= destSize)
+                    goto fail;
 
-				dest[destPos++] = src[srcPos++];
-			}
+                dest[destPos++] = src[srcPos++];
+            }
 
-			if (destPos == destSize) {
-				*uncompressedSize = destSize;
-				return dest;
-			}
+            if (destPos == destSize) {
+                *uncompressedSize = destSize;
+                return dest;
+            }
 
-			flags <<= 1;
-		}
-	}
+            flags <<= 1;
+        }
+    }
 
 fail:
-	FATAL_ERROR("Fatal error while decompressing LZ file.\n");
+    FATAL_ERROR("Fatal error while decompressing LZ file.\n");
 }
 
-unsigned char *LZCompress(unsigned char *src, int srcSize, int *compressedSize, const int minDistance)
-{
-	if (srcSize <= 0)
-		goto fail;
-
-	int worstCaseDestSize = 4 + srcSize + ((srcSize + 7) / 8);
-
-	// Round up to the next multiple of four.
-	worstCaseDestSize = (worstCaseDestSize + 3) & ~3;
-
-	unsigned char *dest = malloc(worstCaseDestSize);
-
-	if (dest == NULL)
-		goto fail;
-
-	// header
-	dest[0] = 0x10; // LZ compression type
-	dest[1] = (unsigned char)srcSize;
-	dest[2] = (unsigned char)(srcSize >> 8);
-	dest[3] = (unsigned char)(srcSize >> 16);
-
-	int srcPos = 0;
-	int destPos = 4;
-
-	for (;;) {
-		unsigned char *flags = &dest[destPos++];
-		*flags = 0;
-
-		for (int i = 0; i < 8; i++) {
-			int bestBlockDistance = 0;
-			int bestBlockSize = 0;
-			int blockDistance = minDistance;
-
-			while (blockDistance <= srcPos && blockDistance <= 0x1000) {
-				int blockStart = srcPos - blockDistance;
-				int blockSize = 0;
-
-				while (blockSize < 18
-				    && srcPos + blockSize < srcSize
-				    && src[blockStart + blockSize] == src[srcPos + blockSize])
-					blockSize++;
-
-				if (blockSize > bestBlockSize) {
-					bestBlockDistance = blockDistance;
-					bestBlockSize = blockSize;
-
-					if (blockSize == 18)
-						break;
-				}
-
-				blockDistance++;
-			}
-
-			if (bestBlockSize >= 3) {
-				*flags |= (0x80 >> i);
-				srcPos += bestBlockSize;
-				bestBlockSize -= 3;
-				bestBlockDistance--;
-				dest[destPos++] = (bestBlockSize << 4) | ((unsigned int)bestBlockDistance >> 8);
-				dest[destPos++] = (unsigned char)bestBlockDistance;
-			} else {
-				dest[destPos++] = src[srcPos++];
-			}
-
-			if (srcPos == srcSize) {
-				// Pad to multiple of 4 bytes.
-				int remainder = destPos % 4;
-
-				if (remainder != 0) {
-					for (int i = 0; i < 4 - remainder; i++)
-						dest[destPos++] = 0;
-				}
-
-				*compressedSize = destPos;
-				return dest;
-			}
-		}
-	}
+unsigned char* LZCompress(unsigned char* src, int srcSize, int* compressedSize, const int minDistance) {
+    if (srcSize <= 0)
+        goto fail;
+
+    int worstCaseDestSize = 4 + srcSize + ((srcSize + 7) / 8);
+
+    // Round up to the next multiple of four.
+    worstCaseDestSize = (worstCaseDestSize + 3) & ~3;
+
+    unsigned char* dest = malloc(worstCaseDestSize);
+
+    if (dest == NULL)
+        goto fail;
+
+    // header
+    dest[0] = 0x10; // LZ compression type
+    dest[1] = (unsigned char)srcSize;
+    dest[2] = (unsigned char)(srcSize >> 8);
+    dest[3] = (unsigned char)(srcSize >> 16);
+
+    int srcPos = 0;
+    int destPos = 4;
+
+    for (;;) {
+        unsigned char* flags = &dest[destPos++];
+        *flags = 0;
+
+        for (int i = 0; i < 8; i++) {
+            int bestBlockDistance = 0;
+            int bestBlockSize = 0;
+            int blockDistance = minDistance;
+
+            while (blockDistance <= srcPos && blockDistance <= 0x1000) {
+                int blockStart = srcPos - blockDistance;
+                int blockSize = 0;
+
+                while (blockSize < 18 && srcPos + blockSize < srcSize &&
+                       src[blockStart + blockSize] == src[srcPos + blockSize])
+                    blockSize++;
+
+                if (blockSize > bestBlockSize) {
+                    bestBlockDistance = blockDistance;
+                    bestBlockSize = blockSize;
+
+                    if (blockSize == 18)
+                        break;
+                }
+
+                blockDistance++;
+            }
+
+            if (bestBlockSize >= 3) {
+                *flags |= (0x80 >> i);
+                srcPos += bestBlockSize;
+                bestBlockSize -= 3;
+                bestBlockDistance--;
+                dest[destPos++] = (bestBlockSize << 4) | ((unsigned int)bestBlockDistance >> 8);
+                dest[destPos++] = (unsigned char)bestBlockDistance;
+            } else {
+                dest[destPos++] = src[srcPos++];
+            }
+
+            if (srcPos == srcSize) {
+                // Pad to multiple of 4 bytes.
+                int remainder = destPos % 4;
+
+                if (remainder != 0) {
+                    for (int i = 0; i < 4 - remainder; i++)
+                        dest[destPos++] = 0;
+                }
+
+                *compressedSize = destPos;
+                return dest;
+            }
+        }
+    }
 
 fail:
-	FATAL_ERROR("Fatal error while compressing LZ file.\n");
+    FATAL_ERROR("Fatal error while compressing LZ file.\n");
 }
diff --git a/tools/src/gbagfx/lz.h b/tools/src/gbagfx/lz.h
index 90f56b64..989aa239 100755..100644
--- a/tools/src/gbagfx/lz.h
+++ b/tools/src/gbagfx/lz.h
@@ -3,7 +3,7 @@
 #ifndef LZ_H
 #define LZ_H
 
-unsigned char *LZDecompress(unsigned char *src, int srcSize, int *uncompressedSize);
-unsigned char *LZCompress(unsigned char *src, int srcSize, int *compressedSize, const int minDistance);
+unsigned char* LZDecompress(unsigned char* src, int srcSize, int* uncompressedSize);
+unsigned char* LZCompress(unsigned char* src, int srcSize, int* compressedSize, const int minDistance);
 
 #endif // LZ_H
diff --git a/tools/src/gbagfx/main.c b/tools/src/gbagfx/main.c
index aa0681fb..d353e2b4 100755..100644
--- a/tools/src/gbagfx/main.c
+++ b/tools/src/gbagfx/main.c
@@ -14,28 +14,24 @@
 #include "font.h"
 #include "huff.h"
 
-struct CommandHandler
-{
-    const char *inputFileExtension;
-    const char *outputFileExtension;
-    void(*function)(char *inputPath, char *outputPath, int argc, char **argv);
+struct CommandHandler {
+    const char* inputFileExtension;
+    const char* outputFileExtension;
+    void (*function)(char* inputPath, char* outputPath, int argc, char** argv);
 };
 
-void ConvertGbaToPng(char *inputPath, char *outputPath, struct GbaToPngOptions *options)
-{
+void ConvertGbaToPng(char* inputPath, char* outputPath, struct GbaToPngOptions* options) {
     struct Image image;
 
-    if (options->paletteFilePath != NULL)
-    {
+    if (options->paletteFilePath != NULL) {
         ReadGbaPalette(options->paletteFilePath, &image.palette);
         image.hasPalette = true;
-    }
-    else
-    {
+    } else {
         image.hasPalette = false;
     }
 
-    ReadImage(inputPath, options->width, options->bitDepth, options->metatileWidth, options->metatileHeight, &image, !image.hasPalette);
+    ReadImage(inputPath, options->width, options->bitDepth, options->metatileWidth, options->metatileHeight, &image,
+              !image.hasPalette);
 
     image.hasTransparency = options->hasTransparency;
 
@@ -44,22 +40,21 @@ void ConvertGbaToPng(char *inputPath, char *outputPath, struct GbaToPngOptions *
     FreeImage(&image);
 }
 
-void ConvertPngToGba(char *inputPath, char *outputPath, struct PngToGbaOptions *options)
-{
+void ConvertPngToGba(char* inputPath, char* outputPath, struct PngToGbaOptions* options) {
     struct Image image;
 
     image.bitDepth = options->bitDepth;
 
     ReadPng(inputPath, &image);
 
-    WriteImage(outputPath, options->numTiles, options->bitDepth, options->metatileWidth, options->metatileHeight, &image, !image.hasPalette);
+    WriteImage(outputPath, options->numTiles, options->bitDepth, options->metatileWidth, options->metatileHeight,
+               &image, !image.hasPalette);
 
     FreeImage(&image);
 }
 
-void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **argv)
-{
-    char *inputFileExtension = GetFileExtension(inputPath);
+void HandleGbaToPngCommand(char* inputPath, char* outputPath, int argc, char** argv) {
+    char* inputFileExtension = GetFileExtension(inputPath);
     struct GbaToPngOptions options;
     options.paletteFilePath = NULL;
     options.bitDepth = inputFileExtension[0] - '0';
@@ -68,25 +63,19 @@ void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **a
     options.metatileWidth = 1;
     options.metatileHeight = 1;
 
-    for (int i = 3; i < argc; i++)
-    {
-        char *option = argv[i];
+    for (int i = 3; i < argc; i++) {
+        char* option = argv[i];
 
-        if (strcmp(option, "-palette") == 0)
-        {
+        if (strcmp(option, "-palette") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No palette file path following \"-palette\".\n");
 
             i++;
 
             options.paletteFilePath = argv[i];
-        }
-        else if (strcmp(option, "-object") == 0)
-        {
+        } else if (strcmp(option, "-object") == 0) {
             options.hasTransparency = true;
-        }
-        else if (strcmp(option, "-width") == 0)
-        {
+        } else if (strcmp(option, "-width") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No width following \"-width\".\n");
 
@@ -97,9 +86,7 @@ void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **a
 
             if (options.width < 1)
                 FATAL_ERROR("Width must be positive.\n");
-        }
-        else if (strcmp(option, "-mwidth") == 0)
-        {
+        } else if (strcmp(option, "-mwidth") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No metatile width value following \"-mwidth\".\n");
 
@@ -110,9 +97,7 @@ void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **a
 
             if (options.metatileWidth < 1)
                 FATAL_ERROR("metatile width must be positive.\n");
-        }
-        else if (strcmp(option, "-mheight") == 0)
-        {
+        } else if (strcmp(option, "-mheight") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No metatile height value following \"-mheight\".\n");
 
@@ -123,9 +108,7 @@ void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **a
 
             if (options.metatileHeight < 1)
                 FATAL_ERROR("metatile height must be positive.\n");
-        }
-        else
-        {
+        } else {
             FATAL_ERROR("Unrecognized option \"%s\".\n", option);
         }
     }
@@ -136,9 +119,8 @@ void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **a
     ConvertGbaToPng(inputPath, outputPath, &options);
 }
 
-void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **argv)
-{
-    char *outputFileExtension = GetFileExtension(outputPath);
+void HandlePngToGbaCommand(char* inputPath, char* outputPath, int argc, char** argv) {
+    char* outputFileExtension = GetFileExtension(outputPath);
     int bitDepth = outputFileExtension[0] - '0';
     struct PngToGbaOptions options;
     options.numTiles = 0;
@@ -146,12 +128,10 @@ void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **a
     options.metatileWidth = 1;
     options.metatileHeight = 1;
 
-    for (int i = 3; i < argc; i++)
-    {
-        char *option = argv[i];
+    for (int i = 3; i < argc; i++) {
+        char* option = argv[i];
 
-        if (strcmp(option, "-num_tiles") == 0)
-        {
+        if (strcmp(option, "-num_tiles") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No number of tiles following \"-num_tiles\".\n");
 
@@ -162,9 +142,7 @@ void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **a
 
             if (options.numTiles < 1)
                 FATAL_ERROR("Number of tiles must be positive.\n");
-        }
-        else if (strcmp(option, "-mwidth") == 0)
-        {
+        } else if (strcmp(option, "-mwidth") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No metatile width value following \"-mwidth\".\n");
 
@@ -175,9 +153,7 @@ void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **a
 
             if (options.metatileWidth < 1)
                 FATAL_ERROR("metatile width must be positive.\n");
-        }
-        else if (strcmp(option, "-mheight") == 0)
-        {
+        } else if (strcmp(option, "-mheight") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No metatile height value following \"-mheight\".\n");
 
@@ -188,9 +164,7 @@ void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **a
 
             if (options.metatileHeight < 1)
                 FATAL_ERROR("metatile height must be positive.\n");
-        }
-        else
-        {
+        } else {
             FATAL_ERROR("Unrecognized option \"%s\".\n", option);
         }
     }
@@ -198,32 +172,27 @@ void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **a
     ConvertPngToGba(inputPath, outputPath, &options);
 }
 
-void HandlePngToGbaPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandlePngToGbaPaletteCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Palette palette;
 
     ReadPngPalette(inputPath, &palette);
     WriteGbaPalette(outputPath, &palette);
 }
 
-void HandleGbaToJascPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleGbaToJascPaletteCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Palette palette;
 
     ReadGbaPalette(inputPath, &palette);
     WriteJascPalette(outputPath, &palette);
 }
 
-void HandleJascToGbaPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv)
-{
+void HandleJascToGbaPaletteCommand(char* inputPath, char* outputPath, int argc, char** argv) {
     int numColors = 0;
 
-    for (int i = 3; i < argc; i++)
-    {
-        char *option = argv[i];
+    for (int i = 3; i < argc; i++) {
+        char* option = argv[i];
 
-        if (strcmp(option, "-num_colors") == 0)
-        {
+        if (strcmp(option, "-num_colors") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No number of colors following \"-num_colors\".\n");
 
@@ -234,9 +203,7 @@ void HandleJascToGbaPaletteCommand(char *inputPath, char *outputPath, int argc,
 
             if (numColors < 1)
                 FATAL_ERROR("Number of colors must be positive.\n");
-        }
-        else
-        {
+        } else {
             FATAL_ERROR("Unrecognized option \"%s\".\n", option);
         }
     }
@@ -251,8 +218,7 @@ void HandleJascToGbaPaletteCommand(char *inputPath, char *outputPath, int argc,
     WriteGbaPalette(outputPath, &palette);
 }
 
-void HandleLatinFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleLatinFontToPngCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Image image;
 
     ReadLatinFont(inputPath, &image);
@@ -261,8 +227,7 @@ void HandleLatinFontToPngCommand(char *inputPath, char *outputPath, int argc UNU
     FreeImage(&image);
 }
 
-void HandlePngToLatinFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandlePngToLatinFontCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Image image;
 
     image.bitDepth = 2;
@@ -273,8 +238,7 @@ void HandlePngToLatinFontCommand(char *inputPath, char *outputPath, int argc UNU
     FreeImage(&image);
 }
 
-void HandleHalfwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleHalfwidthJapaneseFontToPngCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Image image;
 
     ReadHalfwidthJapaneseFont(inputPath, &image);
@@ -283,8 +247,7 @@ void HandleHalfwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath,
     FreeImage(&image);
 }
 
-void HandlePngToHalfwidthJapaneseFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandlePngToHalfwidthJapaneseFontCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Image image;
 
     image.bitDepth = 2;
@@ -295,8 +258,7 @@ void HandlePngToHalfwidthJapaneseFontCommand(char *inputPath, char *outputPath,
     FreeImage(&image);
 }
 
-void HandleFullwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleFullwidthJapaneseFontToPngCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Image image;
 
     ReadFullwidthJapaneseFont(inputPath, &image);
@@ -305,8 +267,7 @@ void HandleFullwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath,
     FreeImage(&image);
 }
 
-void HandlePngToFullwidthJapaneseFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandlePngToFullwidthJapaneseFontCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     struct Image image;
 
     image.bitDepth = 2;
@@ -317,17 +278,14 @@ void HandlePngToFullwidthJapaneseFontCommand(char *inputPath, char *outputPath,
     FreeImage(&image);
 }
 
-void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char **argv)
-{
+void HandleLZCompressCommand(char* inputPath, char* outputPath, int argc, char** argv) {
     int overflowSize = 0;
     int minDistance = 2; // default, for compatibility with LZ77UnCompVram()
 
-    for (int i = 3; i < argc; i++)
-    {
-        char *option = argv[i];
+    for (int i = 3; i < argc; i++) {
+        char* option = argv[i];
 
-        if (strcmp(option, "-overflow") == 0)
-        {
+        if (strcmp(option, "-overflow") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No size following \"-overflow\".\n");
 
@@ -338,9 +296,7 @@ void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char *
 
             if (overflowSize < 1)
                 FATAL_ERROR("Overflow size must be positive.\n");
-        }
-        else if (strcmp(option, "-search") == 0)
-        {
+        } else if (strcmp(option, "-search") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No size following \"-overflow\".\n");
 
@@ -351,9 +307,7 @@ void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char *
 
             if (minDistance < 1)
                 FATAL_ERROR("LZ min search distance must be positive.\n");
-        }
-        else
-        {
+        } else {
             FATAL_ERROR("Unrecognized option \"%s\".\n", option);
         }
     }
@@ -365,10 +319,10 @@ void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char *
     // the data.
 
     int fileSize;
-    unsigned char *buffer = ReadWholeFileZeroPadded(inputPath, &fileSize, overflowSize);
+    unsigned char* buffer = ReadWholeFileZeroPadded(inputPath, &fileSize, overflowSize);
 
     int compressedSize;
-    unsigned char *compressedData = LZCompress(buffer, fileSize + overflowSize, &compressedSize, minDistance);
+    unsigned char* compressedData = LZCompress(buffer, fileSize + overflowSize, &compressedSize, minDistance);
 
     compressedData[1] = (unsigned char)fileSize;
     compressedData[2] = (unsigned char)(fileSize >> 8);
@@ -381,13 +335,12 @@ void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char *
     free(compressedData);
 }
 
-void HandleLZDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleLZDecompressCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     int fileSize;
-    unsigned char *buffer = ReadWholeFile(inputPath, &fileSize);
+    unsigned char* buffer = ReadWholeFile(inputPath, &fileSize);
 
     int uncompressedSize;
-    unsigned char *uncompressedData = LZDecompress(buffer, fileSize, &uncompressedSize);
+    unsigned char* uncompressedData = LZDecompress(buffer, fileSize, &uncompressedSize);
 
     free(buffer);
 
@@ -396,13 +349,12 @@ void HandleLZDecompressCommand(char *inputPath, char *outputPath, int argc UNUSE
     free(uncompressedData);
 }
 
-void HandleRLCompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleRLCompressCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     int fileSize;
-    unsigned char *buffer = ReadWholeFile(inputPath, &fileSize);
+    unsigned char* buffer = ReadWholeFile(inputPath, &fileSize);
 
     int compressedSize;
-    unsigned char *compressedData = RLCompress(buffer, fileSize, &compressedSize);
+    unsigned char* compressedData = RLCompress(buffer, fileSize, &compressedSize);
 
     free(buffer);
 
@@ -411,13 +363,12 @@ void HandleRLCompressCommand(char *inputPath, char *outputPath, int argc UNUSED,
     free(compressedData);
 }
 
-void HandleRLDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleRLDecompressCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     int fileSize;
-    unsigned char *buffer = ReadWholeFile(inputPath, &fileSize);
+    unsigned char* buffer = ReadWholeFile(inputPath, &fileSize);
 
     int uncompressedSize;
-    unsigned char *uncompressedData = RLDecompress(buffer, fileSize, &uncompressedSize);
+    unsigned char* uncompressedData = RLDecompress(buffer, fileSize, &uncompressedSize);
 
     free(buffer);
 
@@ -426,17 +377,14 @@ void HandleRLDecompressCommand(char *inputPath, char *outputPath, int argc UNUSE
     free(uncompressedData);
 }
 
-void HandleHuffCompressCommand(char *inputPath, char *outputPath, int argc, char **argv)
-{
+void HandleHuffCompressCommand(char* inputPath, char* outputPath, int argc, char** argv) {
     int fileSize;
     int bitDepth = 4;
 
-    for (int i = 3; i < argc; i++)
-    {
-        char *option = argv[i];
+    for (int i = 3; i < argc; i++) {
+        char* option = argv[i];
 
-        if (strcmp(option, "-depth") == 0)
-        {
+        if (strcmp(option, "-depth") == 0) {
             if (i + 1 >= argc)
                 FATAL_ERROR("No size following \"-depth\".\n");
 
@@ -447,17 +395,15 @@ void HandleHuffCompressCommand(char *inputPath, char *outputPath, int argc, char
 
             if (bitDepth != 4 && bitDepth != 8)
                 FATAL_ERROR("GBA only supports bit depth of 4 or 8.\n");
-        }
-        else
-        {
+        } else {
             FATAL_ERROR("Unrecognized option \"%s\".\n", option);
         }
     }
 
-    unsigned char *buffer = ReadWholeFile(inputPath, &fileSize);
+    unsigned char* buffer = ReadWholeFile(inputPath, &fileSize);
 
     int compressedSize;
-    unsigned char *compressedData = HuffCompress(buffer, fileSize, &compressedSize, bitDepth);
+    unsigned char* compressedData = HuffCompress(buffer, fileSize, &compressedSize, bitDepth);
 
     free(buffer);
 
@@ -466,13 +412,12 @@ void HandleHuffCompressCommand(char *inputPath, char *outputPath, int argc, char
     free(compressedData);
 }
 
-void HandleHuffDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
-{
+void HandleHuffDecompressCommand(char* inputPath, char* outputPath, int argc UNUSED, char** argv UNUSED) {
     int fileSize;
-    unsigned char *buffer = ReadWholeFile(inputPath, &fileSize);
+    unsigned char* buffer = ReadWholeFile(inputPath, &fileSize);
 
     int uncompressedSize;
-    unsigned char *uncompressedData = HuffDecompress(buffer, fileSize, &uncompressedSize);
+    unsigned char* uncompressedData = HuffDecompress(buffer, fileSize, &uncompressedSize);
 
     free(buffer);
 
@@ -481,41 +426,37 @@ void HandleHuffDecompressCommand(char *inputPath, char *outputPath, int argc UNU
     free(uncompressedData);
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char** argv) {
     if (argc < 3)
         FATAL_ERROR("Usage: gbagfx INPUT_PATH OUTPUT_PATH [options...]\n");
 
-    struct CommandHandler handlers[] =
-    {
-        { "1bpp", "png", HandleGbaToPngCommand },
-        { "4bpp", "png", HandleGbaToPngCommand },
-        { "8bpp", "png", HandleGbaToPngCommand },
-        { "png", "1bpp", HandlePngToGbaCommand },
-        { "png", "4bpp", HandlePngToGbaCommand },
-        { "png", "8bpp", HandlePngToGbaCommand },
-        { "png", "gbapal", HandlePngToGbaPaletteCommand },
-        { "gbapal", "pal", HandleGbaToJascPaletteCommand },
-        { "pal", "gbapal", HandleJascToGbaPaletteCommand },
-        { "latfont", "png", HandleLatinFontToPngCommand },
-        { "png", "latfont", HandlePngToLatinFontCommand },
-        { "hwjpnfont", "png", HandleHalfwidthJapaneseFontToPngCommand },
-        { "png", "hwjpnfont", HandlePngToHalfwidthJapaneseFontCommand },
-        { "fwjpnfont", "png", HandleFullwidthJapaneseFontToPngCommand },
-        { "png", "fwjpnfont", HandlePngToFullwidthJapaneseFontCommand },
-        { NULL, "huff", HandleHuffCompressCommand },
-        { NULL, "lz", HandleLZCompressCommand },
-        { "huff", NULL, HandleHuffDecompressCommand },
-        { "lz", NULL, HandleLZDecompressCommand },
-        { NULL, "rl", HandleRLCompressCommand },
-        { "rl", NULL, HandleRLDecompressCommand },
-        { NULL, NULL, NULL }
-    };
-
-    char *inputPath = argv[1];
-    char *outputPath = argv[2];
-    char *inputFileExtension = GetFileExtension(inputPath);
-    char *outputFileExtension = GetFileExtension(outputPath);
+    struct CommandHandler handlers[] = { { "1bpp", "png", HandleGbaToPngCommand },
+                                         { "4bpp", "png", HandleGbaToPngCommand },
+                                         { "8bpp", "png", HandleGbaToPngCommand },
+                                         { "png", "1bpp", HandlePngToGbaCommand },
+                                         { "png", "4bpp", HandlePngToGbaCommand },
+                                         { "png", "8bpp", HandlePngToGbaCommand },
+                                         { "png", "gbapal", HandlePngToGbaPaletteCommand },
+                                         { "gbapal", "pal", HandleGbaToJascPaletteCommand },
+                                         { "pal", "gbapal", HandleJascToGbaPaletteCommand },
+                                         { "latfont", "png", HandleLatinFontToPngCommand },
+                                         { "png", "latfont", HandlePngToLatinFontCommand },
+                                         { "hwjpnfont", "png", HandleHalfwidthJapaneseFontToPngCommand },
+                                         { "png", "hwjpnfont", HandlePngToHalfwidthJapaneseFontCommand },
+                                         { "fwjpnfont", "png", HandleFullwidthJapaneseFontToPngCommand },
+                                         { "png", "fwjpnfont", HandlePngToFullwidthJapaneseFontCommand },
+                                         { NULL, "huff", HandleHuffCompressCommand },
+                                         { NULL, "lz", HandleLZCompressCommand },
+                                         { "huff", NULL, HandleHuffDecompressCommand },
+                                         { "lz", NULL, HandleLZDecompressCommand },
+                                         { NULL, "rl", HandleRLCompressCommand },
+                                         { "rl", NULL, HandleRLDecompressCommand },
+                                         { NULL, NULL, NULL } };
+
+    char* inputPath = argv[1];
+    char* outputPath = argv[2];
+    char* inputFileExtension = GetFileExtension(inputPath);
+    char* outputFileExtension = GetFileExtension(outputPath);
 
     if (inputFileExtension == NULL)
         FATAL_ERROR("Input file \"%s\" has no extension.\n", inputPath);
@@ -523,11 +464,11 @@ int main(int argc, char **argv)
     if (outputFileExtension == NULL)
         FATAL_ERROR("Output file \"%s\" has no extension.\n", outputPath);
 
-    for (int i = 0; handlers[i].function != NULL; i++)
-    {
-        if ((handlers[i].inputFileExtension == NULL || strcmp(handlers[i].inputFileExtension, inputFileExtension) == 0)
-            && (handlers[i].outputFileExtension == NULL || strcmp(handlers[i].outputFileExtension, outputFileExtension) == 0))
-        {
+    for (int i = 0; handlers[i].function != NULL; i++) {
+        if ((handlers[i].inputFileExtension == NULL ||
+             strcmp(handlers[i].inputFileExtension, inputFileExtension) == 0) &&
+            (handlers[i].outputFileExtension == NULL ||
+             strcmp(handlers[i].outputFileExtension, outputFileExtension) == 0)) {
             handlers[i].function(inputPath, outputPath, argc, argv);
             return 0;
         }
diff --git a/tools/src/gbagfx/options.h b/tools/src/gbagfx/options.h
index 2ff3967a..29536621 100755..100644
--- a/tools/src/gbagfx/options.h
+++ b/tools/src/gbagfx/options.h
@@ -6,7 +6,7 @@
 #include <stdbool.h>
 
 struct GbaToPngOptions {
-    char *paletteFilePath;
+    char* paletteFilePath;
     int bitDepth;
     bool hasTransparency;
     int width;
diff --git a/tools/src/gbagfx/rl.c b/tools/src/gbagfx/rl.c
index 968c9347..697b59c2 100755..100644
--- a/tools/src/gbagfx/rl.c
+++ b/tools/src/gbagfx/rl.c
@@ -5,14 +5,13 @@
 #include "global.h"
 #include "rl.h"
 
-unsigned char *RLDecompress(unsigned char *src, int srcSize, int *uncompressedSize)
-{
+unsigned char* RLDecompress(unsigned char* src, int srcSize, int* uncompressedSize) {
     if (srcSize < 4)
         goto fail;
 
     int destSize = (src[3] << 16) | (src[2] << 8) | src[1];
 
-    unsigned char *dest = malloc(destSize);
+    unsigned char* dest = malloc(destSize);
 
     if (dest == NULL)
         goto fail;
@@ -20,16 +19,14 @@ unsigned char *RLDecompress(unsigned char *src, int srcSize, int *uncompressedSi
     int srcPos = 4;
     int destPos = 0;
 
-    for (;;)
-    {
+    for (;;) {
         if (srcPos >= srcSize)
             goto fail;
 
         unsigned char flags = src[srcPos++];
         bool compressed = ((flags & 0x80) != 0);
 
-        if (compressed)
-        {
+        if (compressed) {
             int length = (flags & 0x7F) + 3;
             unsigned char data = src[srcPos++];
 
@@ -38,9 +35,7 @@ unsigned char *RLDecompress(unsigned char *src, int srcSize, int *uncompressedSi
 
             for (int i = 0; i < length; i++)
                 dest[destPos++] = data;
-        }
-        else
-        {
+        } else {
             int length = (flags & 0x7F) + 1;
 
             if (destPos + length > destSize)
@@ -50,8 +45,7 @@ unsigned char *RLDecompress(unsigned char *src, int srcSize, int *uncompressedSi
                 dest[destPos++] = src[srcPos++];
         }
 
-        if (destPos == destSize)
-        {
+        if (destPos == destSize) {
             *uncompressedSize = destSize;
             return dest;
         }
@@ -61,8 +55,7 @@ fail:
     FATAL_ERROR("Fatal error while decompressing RL file.\n");
 }
 
-unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize)
-{
+unsigned char* RLCompress(unsigned char* src, int srcSize, int* compressedSize) {
     if (srcSize <= 0)
         goto fail;
 
@@ -71,7 +64,7 @@ unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize)
     // Round up to the next multiple of four.
     worstCaseDestSize = (worstCaseDestSize + 3) & ~3;
 
-    unsigned char *dest = malloc(worstCaseDestSize);
+    unsigned char* dest = malloc(worstCaseDestSize);
 
     if (dest == NULL)
         goto fail;
@@ -85,14 +78,12 @@ unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize)
     int srcPos = 0;
     int destPos = 4;
 
-    for (;;)
-    {
+    for (;;) {
         bool compress = false;
         int uncompressedStart = srcPos;
         int uncompressedLength = 0;
 
-        while (srcPos < srcSize && uncompressedLength < (0x7F + 1))
-        {
+        while (srcPos < srcSize && uncompressedLength < (0x7F + 1)) {
             compress = (srcPos + 2 < srcSize && src[srcPos] == src[srcPos + 1] && src[srcPos] == src[srcPos + 2]);
 
             if (compress)
@@ -101,24 +92,20 @@ unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize)
             srcPos++;
             uncompressedLength++;
         }
-        
-        if (uncompressedLength > 0)
-        {
+
+        if (uncompressedLength > 0) {
             dest[destPos++] = uncompressedLength - 1;
 
             for (int i = 0; i < uncompressedLength; i++)
                 dest[destPos++] = src[uncompressedStart + i];
         }
 
-        if (compress)
-        {
+        if (compress) {
             unsigned char data = src[srcPos];
             int compressedLength = 0;
 
-            while (compressedLength < (0x7F + 3)
-                && srcPos + compressedLength < srcSize
-                && src[srcPos + compressedLength] == data)
-            {
+            while (compressedLength < (0x7F + 3) && srcPos + compressedLength < srcSize &&
+                   src[srcPos + compressedLength] == data) {
                 compressedLength++;
             }
 
@@ -128,13 +115,11 @@ unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize)
             srcPos += compressedLength;
         }
 
-        if (srcPos == srcSize)
-        {
+        if (srcPos == srcSize) {
             // Pad to multiple of 4 bytes.
             int remainder = destPos % 4;
 
-            if (remainder != 0)
-            {
+            if (remainder != 0) {
                 for (int i = 0; i < 4 - remainder; i++)
                     dest[destPos++] = 0;
             }
diff --git a/tools/src/gbagfx/rl.h b/tools/src/gbagfx/rl.h
index 02ad8d6d..4a366c39 100755..100644
--- a/tools/src/gbagfx/rl.h
+++ b/tools/src/gbagfx/rl.h
@@ -3,7 +3,7 @@
 #ifndef RL_H
 #define RL_H
 
-unsigned char *RLDecompress(unsigned char *src, int srcSize, int *uncompressedSize);
-unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize);
+unsigned char* RLDecompress(unsigned char* src, int srcSize, int* uncompressedSize);
+unsigned char* RLCompress(unsigned char* src, int srcSize, int* compressedSize);
 
 #endif // RL_H
diff --git a/tools/src/gbagfx/util.c b/tools/src/gbagfx/util.c
index 87abeb31..c2230fb2 100755..100644
--- a/tools/src/gbagfx/util.c
+++ b/tools/src/gbagfx/util.c
@@ -9,116 +9,111 @@
 #include "global.h"
 #include "util.h"
 
-bool ParseNumber(char *s, char **end, int radix, int *intValue)
-{
-	char *localEnd;
+bool ParseNumber(char* s, char** end, int radix, int* intValue) {
+    char* localEnd;
 
-	if (end == NULL)
-		end = &localEnd;
+    if (end == NULL)
+        end = &localEnd;
 
-	errno = 0;
+    errno = 0;
 
-	const long longValue = strtol(s, end, radix);
+    const long longValue = strtol(s, end, radix);
 
-	if (*end == s)
-		return false; // not a number
+    if (*end == s)
+        return false; // not a number
 
-	if ((longValue == LONG_MIN || longValue == LONG_MAX) && errno == ERANGE)
-		return false;
+    if ((longValue == LONG_MIN || longValue == LONG_MAX) && errno == ERANGE)
+        return false;
 
-	if (longValue > INT_MAX)
-		return false;
+    if (longValue > INT_MAX)
+        return false;
 
-	if (longValue < INT_MIN)
-		return false;
+    if (longValue < INT_MIN)
+        return false;
 
-	*intValue = (int)longValue;
+    *intValue = (int)longValue;
 
-	return true;
+    return true;
 }
 
-char *GetFileExtension(char *path)
-{
-	char *extension = path;
+char* GetFileExtension(char* path) {
+    char* extension = path;
 
-	while (*extension != 0)
-		extension++;
+    while (*extension != 0)
+        extension++;
 
-	while (extension > path && *extension != '.')
-		extension--;
+    while (extension > path && *extension != '.')
+        extension--;
 
-	if (extension == path)
-		return NULL;
+    if (extension == path)
+        return NULL;
 
-	extension++;
+    extension++;
 
-	if (*extension == 0)
-		return NULL;
+    if (*extension == 0)
+        return NULL;
 
-	return extension;
+    return extension;
 }
 
-unsigned char *ReadWholeFile(char *path, int *size)
-{
-	FILE *fp = fopen(path, "rb");
+unsigned char* ReadWholeFile(char* path, int* size) {
+    FILE* fp = fopen(path, "rb");
 
-	if (fp == NULL)
-		FATAL_ERROR("Failed to open \"%s\" for reading.\n", path);
+    if (fp == NULL)
+        FATAL_ERROR("Failed to open \"%s\" for reading.\n", path);
 
-	fseek(fp, 0, SEEK_END);
+    fseek(fp, 0, SEEK_END);
 
-	*size = ftell(fp);
+    *size = ftell(fp);
 
-	unsigned char *buffer = malloc(*size);
+    unsigned char* buffer = malloc(*size);
 
-	if (buffer == NULL)
-		FATAL_ERROR("Failed to allocate memory for reading \"%s\".\n", path);
+    if (buffer == NULL)
+        FATAL_ERROR("Failed to allocate memory for reading \"%s\".\n", path);
 
-	rewind(fp);
+    rewind(fp);
 
-	if (fread(buffer, *size, 1, fp) != 1)
-		FATAL_ERROR("Failed to read \"%s\".\n", path);
+    if (fread(buffer, *size, 1, fp) != 1)
+        FATAL_ERROR("Failed to read \"%s\".\n", path);
 
-	fclose(fp);
+    fclose(fp);
 
-	return buffer;
+    return buffer;
 }
 
-unsigned char *ReadWholeFileZeroPadded(char *path, int *size, int padAmount)
-{
-	FILE *fp = fopen(path, "rb");
+unsigned char* ReadWholeFileZeroPadded(char* path, int* size, int padAmount) {
+    FILE* fp = fopen(path, "rb");
 
-	if (fp == NULL)
-		FATAL_ERROR("Failed to open \"%s\" for reading.\n", path);
+    if (fp == NULL)
+        FATAL_ERROR("Failed to open \"%s\" for reading.\n", path);
 
-	fseek(fp, 0, SEEK_END);
+    fseek(fp, 0, SEEK_END);
 
-	*size = ftell(fp);
+    *size = ftell(fp);
 
-	unsigned char *buffer = calloc(*size + padAmount, 1);
+    unsigned char* buffer = calloc(*size + padAmount, 1);
 
-	if (buffer == NULL)
-		FATAL_ERROR("Failed to allocate memory for reading \"%s\".\n", path);
+    if (buffer == NULL)
+        FATAL_ERROR("Failed to allocate memory for reading \"%s\".\n", path);
 
-	rewind(fp);
+    rewind(fp);
 
-	if (fread(buffer, *size, 1, fp) != 1)
-		FATAL_ERROR("Failed to read \"%s\".\n", path);
+    if (fread(buffer, *size, 1, fp) != 1)
+        FATAL_ERROR("Failed to read \"%s\".\n", path);
 
-	fclose(fp);
+    fclose(fp);
 
-	return buffer;
+    return buffer;
 }
 
-void WriteWholeFile(char *path, void *buffer, int bufferSize)
-{
-	FILE *fp = fopen(path, "wb");
+void WriteWholeFile(char* path, void* buffer, int bufferSize) {
+    FILE* fp = fopen(path, "wb");
 
-	if (fp == NULL)
-		FATAL_ERROR("Failed to open \"%s\" for writing.\n", path);
+    if (fp == NULL)
+        FATAL_ERROR("Failed to open \"%s\" for writing.\n", path);
 
-	if (fwrite(buffer, bufferSize, 1, fp) != 1)
-		FATAL_ERROR("Failed to write to \"%s\".\n", path);
+    if (fwrite(buffer, bufferSize, 1, fp) != 1)
+        FATAL_ERROR("Failed to write to \"%s\".\n", path);
 
-	fclose(fp);
+    fclose(fp);
 }
diff --git a/tools/src/gbagfx/util.h b/tools/src/gbagfx/util.h
index 6d7a9c21..62b6d8d7 100755..100644
--- a/tools/src/gbagfx/util.h
+++ b/tools/src/gbagfx/util.h
@@ -5,10 +5,10 @@
 
 #include <stdbool.h>
 
-bool ParseNumber(char *s, char **end, int radix, int *intValue);
-char *GetFileExtension(char *path);
-unsigned char *ReadWholeFile(char *path, int *size);
-unsigned char *ReadWholeFileZeroPadded(char *path, int *size, int padAmount);
-void WriteWholeFile(char *path, void *buffer, int bufferSize);
+bool ParseNumber(char* s, char** end, int radix, int* intValue);
+char* GetFileExtension(char* path);
+unsigned char* ReadWholeFile(char* path, int* size);
+unsigned char* ReadWholeFileZeroPadded(char* path, int* size, int padAmount);
+void WriteWholeFile(char* path, void* buffer, int bufferSize);
 
 #endif // UTIL_H
diff --git a/tools/src/mid2agb/agb.cpp b/tools/src/mid2agb/agb.cpp
index 9e0feb8c..361f67f0 100755..100644
--- a/tools/src/mid2agb/agb.cpp
+++ b/tools/src/mid2agb/agb.cpp
@@ -42,8 +42,7 @@ static int s_memaccOp;
 static int s_memaccParam1;
 static int s_memaccParam2;
 
-void PrintAgbHeader()
-{
+void PrintAgbHeader() {
     std::fprintf(g_outputFile, "\t.include \"sound/MPlayDef.s\"\n\n");
     std::fprintf(g_outputFile, "\t.equ\t%s_grp, voicegroup%03u\n", g_asmLabel.c_str(), g_voiceGroup);
     std::fprintf(g_outputFile, "\t.equ\t%s_pri, %u\n", g_asmLabel.c_str(), g_priority);
@@ -65,8 +64,7 @@ void PrintAgbHeader()
     std::fprintf(g_outputFile, "\t.align\t2\n");
 }
 
-void ResetTrackVars()
-{
+void ResetTrackVars() {
     s_lastVelocity = -1;
     s_lastNote = -1;
     s_velocityChanged = false;
@@ -76,10 +74,8 @@ void ResetTrackVars()
     s_inPattern = false;
 }
 
-void PrintWait(int wait)
-{
-    if (wait > 0)
-    {
+void PrintWait(int wait) {
+    if (wait > 0) {
         std::fprintf(g_outputFile, "\t.byte\tW%02d\n", wait);
         s_velocityChanged = true;
         s_noteChanged = true;
@@ -87,27 +83,20 @@ void PrintWait(int wait)
     }
 }
 
-void PrintOp(int wait, std::string name, const char *format, ...)
-{
+void PrintOp(int wait, std::string name, const char* format, ...) {
     std::va_list args;
     va_start(args, format);
     std::fprintf(g_outputFile, "\t.byte\t\t");
 
-    if (format != nullptr)
-    {
-        if (!g_compressionEnabled || s_lastOpName != name)
-        {
+    if (format != nullptr) {
+        if (!g_compressionEnabled || s_lastOpName != name) {
             std::fprintf(g_outputFile, "%s, ", name.c_str());
             s_lastOpName = name;
-        }
-        else
-        {
+        } else {
             std::fprintf(g_outputFile, "        ");
         }
         std::vfprintf(g_outputFile, format, args);
-    }
-    else
-    {
+    } else {
         std::fputs(name.c_str(), g_outputFile);
         s_lastOpName = name;
     }
@@ -119,8 +108,7 @@ void PrintOp(int wait, std::string name, const char *format, ...)
     PrintWait(wait);
 }
 
-void PrintByte(const char *format, ...)
-{
+void PrintByte(const char* format, ...) {
     std::va_list args;
     va_start(args, format);
     std::fprintf(g_outputFile, "\t.byte\t");
@@ -132,8 +120,7 @@ void PrintByte(const char *format, ...)
     va_end(args);
 }
 
-void PrintWord(const char *format, ...)
-{
+void PrintWord(const char* format, ...) {
     std::va_list args;
     va_start(args, format);
     std::fprintf(g_outputFile, "\t .word\t");
@@ -142,8 +129,7 @@ void PrintWord(const char *format, ...)
     va_end(args);
 }
 
-void PrintNote(const Event& event)
-{
+void PrintNote(const Event& event) {
     int note = event.note;
     int velocity = g_noteVelocityLUT[event.param1];
     int duration = -1;
@@ -173,8 +159,7 @@ void PrintNote(const Event& event)
     bool noteChanged = true;
     bool velocityChanged = true;
 
-    if (g_compressionEnabled)
-    {
+    if (g_compressionEnabled) {
         noteChanged = (note != s_lastNote);
         velocityChanged = (velocity != s_lastVelocity);
     }
@@ -184,8 +169,7 @@ void PrintNote(const Event& event)
     else
         s_lastOpName = "";
 
-    if (noteChanged || velocityChanged || (gateTimeParam > 0))
-    {
+    if (noteChanged || velocityChanged || (gateTimeParam > 0)) {
         s_lastNote = note;
 
         char noteBuf[16];
@@ -197,20 +181,15 @@ void PrintNote(const Event& event)
 
         char velocityBuf[16];
 
-        if (velocityChanged || (gateTimeParam > 0))
-        {
+        if (velocityChanged || (gateTimeParam > 0)) {
             s_lastVelocity = velocity;
             std::snprintf(velocityBuf, sizeof(velocityBuf), ", v%03u", velocity);
-        }
-        else
-        {
+        } else {
             velocityBuf[0] = 0;
         }
 
         PrintOp(event.time, opName, "%s%s%s", noteBuf, velocityBuf, gtpBuf);
-    }
-    else
-    {
+    } else {
         PrintOp(event.time, opName, 0);
     }
 
@@ -218,20 +197,16 @@ void PrintNote(const Event& event)
     s_velocityChanged = velocityChanged;
 }
 
-void PrintEndOfTieOp(const Event& event)
-{
+void PrintEndOfTieOp(const Event& event) {
     int note = event.note;
     bool noteChanged = (note != s_lastNote);
 
     if (!noteChanged || !s_noteChanged)
         s_lastOpName = "";
 
-    if (!noteChanged && g_compressionEnabled)
-    {
+    if (!noteChanged && g_compressionEnabled) {
         PrintOp(event.time, "EOT   ", nullptr);
-    }
-    else
-    {
+    } else {
         s_lastNote = note;
         if (note >= 24)
             PrintOp(event.time, "EOT   ", g_noteTable[note % 12], note / 12 - 2);
@@ -242,181 +217,174 @@ void PrintEndOfTieOp(const Event& event)
     s_noteChanged = noteChanged;
 }
 
-void PrintSeqLoopLabel(const Event& event)
-{
+void PrintSeqLoopLabel(const Event& event) {
     s_blockNum = event.param1 + 1;
     std::fprintf(g_outputFile, "%s_%u_B%u::\n", g_asmLabel.c_str(), g_agbTrack, s_blockNum);
     PrintWait(event.time);
     ResetTrackVars();
 }
 
-void PrintMemAcc(const Event& event)
-{
-    switch (s_memaccOp)
-    {
-    case 0x00:
-        PrintByte("MEMACC, mem_set, 0x%02X, %u", s_memaccParam1, event.param2);
-        break;
-    case 0x01:
-        PrintByte("MEMACC, mem_add, 0x%02X, %u", s_memaccParam1, event.param2);
-        break;
-    case 0x02:
-        PrintByte("MEMACC, mem_sub, 0x%02X, %u", s_memaccParam1, event.param2);
-        break;
-    case 0x03:
-        PrintByte("MEMACC, mem_mem_set, 0x%02X, 0x%02X", s_memaccParam1, event.param2);
-        break;
-    case 0x04:
-        PrintByte("MEMACC, mem_mem_add, 0x%02X, 0x%02X", s_memaccParam1, event.param2);
-        break;
-    case 0x05:
-        PrintByte("MEMACC, mem_mem_sub, 0x%02X, 0x%02X", s_memaccParam1, event.param2);
-        break;
-    // TODO: everything else
-    case 0x06:
-        break;
-    case 0x07:
-        break;
-    case 0x08:
-        break;
-    case 0x09:
-        break;
-    case 0x0A:
-        break;
-    case 0x0B:
-        break;
-    case 0x0C:
-        break;
-    case 0x0D:
-        break;
-    case 0x0E:
-        break;
-    case 0x0F:
-        break;
-    case 0x10:
-        break;
-    case 0x11:
-        break;
-    case 0x46:
-        break;
-    case 0x47:
-        break;
-    case 0x48:
-        break;
-    case 0x49:
-        break;
-    case 0x4A:
-        break;
-    case 0x4B:
-        break;
-    case 0x4C:
-        break;
-    case 0x4D:
-        break;
-    case 0x4E:
-        break;
-    case 0x4F:
-        break;
-    case 0x50:
-        break;
-    case 0x51:
-        break;
-    default:
-        break;
+void PrintMemAcc(const Event& event) {
+    switch (s_memaccOp) {
+        case 0x00:
+            PrintByte("MEMACC, mem_set, 0x%02X, %u", s_memaccParam1, event.param2);
+            break;
+        case 0x01:
+            PrintByte("MEMACC, mem_add, 0x%02X, %u", s_memaccParam1, event.param2);
+            break;
+        case 0x02:
+            PrintByte("MEMACC, mem_sub, 0x%02X, %u", s_memaccParam1, event.param2);
+            break;
+        case 0x03:
+            PrintByte("MEMACC, mem_mem_set, 0x%02X, 0x%02X", s_memaccParam1, event.param2);
+            break;
+        case 0x04:
+            PrintByte("MEMACC, mem_mem_add, 0x%02X, 0x%02X", s_memaccParam1, event.param2);
+            break;
+        case 0x05:
+            PrintByte("MEMACC, mem_mem_sub, 0x%02X, 0x%02X", s_memaccParam1, event.param2);
+            break;
+        // TODO: everything else
+        case 0x06:
+            break;
+        case 0x07:
+            break;
+        case 0x08:
+            break;
+        case 0x09:
+            break;
+        case 0x0A:
+            break;
+        case 0x0B:
+            break;
+        case 0x0C:
+            break;
+        case 0x0D:
+            break;
+        case 0x0E:
+            break;
+        case 0x0F:
+            break;
+        case 0x10:
+            break;
+        case 0x11:
+            break;
+        case 0x46:
+            break;
+        case 0x47:
+            break;
+        case 0x48:
+            break;
+        case 0x49:
+            break;
+        case 0x4A:
+            break;
+        case 0x4B:
+            break;
+        case 0x4C:
+            break;
+        case 0x4D:
+            break;
+        case 0x4E:
+            break;
+        case 0x4F:
+            break;
+        case 0x50:
+            break;
+        case 0x51:
+            break;
+        default:
+            break;
     }
 
     PrintWait(event.time);
 }
 
-void PrintExtendedOp(const Event& event)
-{
+void PrintExtendedOp(const Event& event) {
     // TODO: support for other extended commands
 
-    switch (s_extendedCommand)
-    {
-    case 0x08:
-        PrintOp(event.time, "XCMD  ", "xIECV , %u", event.param2);
-        break;
-    case 0x09:
-        PrintOp(event.time, "XCMD  ", "xIECL , %u", event.param2);
-        break;
-    default:
-        PrintWait(event.time);
-        break;
+    switch (s_extendedCommand) {
+        case 0x08:
+            PrintOp(event.time, "XCMD  ", "xIECV , %u", event.param2);
+            break;
+        case 0x09:
+            PrintOp(event.time, "XCMD  ", "xIECL , %u", event.param2);
+            break;
+        default:
+            PrintWait(event.time);
+            break;
     }
 }
 
-void PrintControllerOp(const Event& event)
-{
-    switch (event.param1)
-    {
-    case 0x01:
-        PrintOp(event.time, "MOD   ", "%u", event.param2);
-        break;
-    case 0x07:
-        PrintOp(event.time, "VOL   ", "%u*%s_mvl/mxv", event.param2, g_asmLabel.c_str());
-        break;
-    case 0x0A:
-        PrintOp(event.time, "PAN   ", "c_v%+d", event.param2 - 64);
-        break;
-    case 0x0C:
-    case 0x10:
-        PrintMemAcc(event);
-        break;
-    case 0x0D:
-        s_memaccOp = event.param2;
-        PrintWait(event.time);
-        break;
-    case 0x0E:
-        s_memaccParam1 = event.param2;
-        PrintWait(event.time);
-        break;
-    case 0x0F:
-        s_memaccParam2 = event.param2;
-        PrintWait(event.time);
-        break;
-    case 0x11:
-        std::fprintf(g_outputFile, "%s_%u_L%u::\n", g_asmLabel.c_str(), g_agbTrack, event.param2);
-        PrintWait(event.time);
-        ResetTrackVars();
-        break;
-    case 0x14:
-        PrintOp(event.time, "BENDR ", "%u", event.param2);
-        break;
-    case 0x15:
-        PrintOp(event.time, "LFOS  ", "%u", event.param2);
-        break;
-    case 0x16:
-        PrintOp(event.time, "MODT  ", "%u", event.param2);
-        break;
-    case 0x18:
-        PrintOp(event.time, "TUNE  ", "c_v%+d", event.param2 - 64);
-        break;
-    case 0x1A:
-        PrintOp(event.time, "LFODL ", "%u", event.param2);
-        break;
-    case 0x1D:
-    case 0x1F:
-        PrintExtendedOp(event);
-        break;
-    case 0x1E:
-        s_extendedCommand = event.param2;
-        // TODO: loop op
-        break;
-    case 0x21:
-    case 0x27:
-        PrintByte("PRIO  , %u", event.param2);
-        PrintWait(event.time);
-        break;
-    default:
-        PrintWait(event.time);
-        break;
+void PrintControllerOp(const Event& event) {
+    switch (event.param1) {
+        case 0x01:
+            PrintOp(event.time, "MOD   ", "%u", event.param2);
+            break;
+        case 0x07:
+            PrintOp(event.time, "VOL   ", "%u*%s_mvl/mxv", event.param2, g_asmLabel.c_str());
+            break;
+        case 0x0A:
+            PrintOp(event.time, "PAN   ", "c_v%+d", event.param2 - 64);
+            break;
+        case 0x0C:
+        case 0x10:
+            PrintMemAcc(event);
+            break;
+        case 0x0D:
+            s_memaccOp = event.param2;
+            PrintWait(event.time);
+            break;
+        case 0x0E:
+            s_memaccParam1 = event.param2;
+            PrintWait(event.time);
+            break;
+        case 0x0F:
+            s_memaccParam2 = event.param2;
+            PrintWait(event.time);
+            break;
+        case 0x11:
+            std::fprintf(g_outputFile, "%s_%u_L%u::\n", g_asmLabel.c_str(), g_agbTrack, event.param2);
+            PrintWait(event.time);
+            ResetTrackVars();
+            break;
+        case 0x14:
+            PrintOp(event.time, "BENDR ", "%u", event.param2);
+            break;
+        case 0x15:
+            PrintOp(event.time, "LFOS  ", "%u", event.param2);
+            break;
+        case 0x16:
+            PrintOp(event.time, "MODT  ", "%u", event.param2);
+            break;
+        case 0x18:
+            PrintOp(event.time, "TUNE  ", "c_v%+d", event.param2 - 64);
+            break;
+        case 0x1A:
+            PrintOp(event.time, "LFODL ", "%u", event.param2);
+            break;
+        case 0x1D:
+        case 0x1F:
+            PrintExtendedOp(event);
+            break;
+        case 0x1E:
+            s_extendedCommand = event.param2;
+            // TODO: loop op
+            break;
+        case 0x21:
+        case 0x27:
+            PrintByte("PRIO  , %u", event.param2);
+            PrintWait(event.time);
+            break;
+        default:
+            PrintWait(event.time);
+            break;
     }
 }
 
-void PrintAgbTrack(std::vector<Event>& events)
-{
-    std::fprintf(g_outputFile, "\n@**************** Track %u (Midi-Chn.%u) ****************@\n\n", g_agbTrack, g_midiChan + 1);
+void PrintAgbTrack(std::vector<Event>& events) {
+    std::fprintf(g_outputFile, "\n@**************** Track %u (Midi-Chn.%u) ****************@\n\n", g_agbTrack,
+                 g_midiChan + 1);
     std::fprintf(g_outputFile, "%s_%u::\n", g_asmLabel.c_str(), g_agbTrack);
 
     int wholeNoteCount = 0;
@@ -426,13 +394,11 @@ void PrintAgbTrack(std::vector<Event>& events)
 
     bool foundVolBeforeNote = false;
 
-    for (const Event& event : events)
-    {
+    for (const Event& event : events) {
         if (event.type == EventType::Note)
             break;
 
-        if (event.type == EventType::Controller && event.param1 == 0x07)
-        {
+        if (event.type == EventType::Controller && event.param1 == 0x07) {
             foundVolBeforeNote = true;
             break;
         }
@@ -444,12 +410,10 @@ void PrintAgbTrack(std::vector<Event>& events)
     PrintWait(g_initialWait);
     PrintByte("KEYSH , %s_key%+d", g_asmLabel.c_str(), 0);
 
-    for (unsigned i = 0; events[i].type != EventType::EndOfTrack; i++)
-    {
+    for (unsigned i = 0; events[i].type != EventType::EndOfTrack; i++) {
         const Event& event = events[i];
 
-        if (IsPatternBoundary(event.type))
-        {
+        if (IsPatternBoundary(event.type)) {
             if (s_inPattern)
                 PrintByte("PEND");
             s_inPattern = false;
@@ -458,75 +422,73 @@ void PrintAgbTrack(std::vector<Event>& events)
         if (event.type == EventType::WholeNoteMark || event.type == EventType::Pattern)
             std::fprintf(g_outputFile, "@ %03d   ----------------------------------------\n", wholeNoteCount++);
 
-        switch (event.type)
-        {
-        case EventType::Note:
-            PrintNote(event);
-            break;
-        case EventType::EndOfTie:
-            PrintEndOfTieOp(event);
-            break;
-        case EventType::Label:
-            PrintSeqLoopLabel(event);
-            break;
-        case EventType::LoopEnd:
-            PrintByte("GOTO"); 
-            PrintWord("%s_%u_B%u", g_asmLabel.c_str(), g_agbTrack, loopEndBlockNum);
-            //PrintSeqLoopLabel(event); // Breaks same note in EOT bgmCrenelStorm 0xDD4356
-            PrintWait(event.time); // instead just print the wait
-            break;
-        case EventType::LoopEndBegin:
-            PrintByte("GOTO");
-            PrintWord("%s_%u_B%u", g_asmLabel.c_str(), g_agbTrack, loopEndBlockNum);
-            PrintSeqLoopLabel(event);
-            loopEndBlockNum = s_blockNum;
-            break;
-        case EventType::LoopBegin:
-            PrintSeqLoopLabel(event);
-            loopEndBlockNum = s_blockNum;
-            break;
-        case EventType::WholeNoteMark:
-            if (event.param2 & 0x80000000)
-            {
-                std::fprintf(g_outputFile, "%s_%u_%03lu::\n", g_asmLabel.c_str(), g_agbTrack, (unsigned long)(event.param2 & 0x7FFFFFFF));
-                ResetTrackVars();
-                s_inPattern = true;
-            }
-            PrintWait(event.time);
-            break;
-        case EventType::Pattern:
-            PrintByte("PATT");
-            PrintWord("%s_%u_%03lu", g_asmLabel.c_str(), g_agbTrack, event.param2);
+        switch (event.type) {
+            case EventType::Note:
+                PrintNote(event);
+                break;
+            case EventType::EndOfTie:
+                PrintEndOfTieOp(event);
+                break;
+            case EventType::Label:
+                PrintSeqLoopLabel(event);
+                break;
+            case EventType::LoopEnd:
+                PrintByte("GOTO");
+                PrintWord("%s_%u_B%u", g_asmLabel.c_str(), g_agbTrack, loopEndBlockNum);
+                // PrintSeqLoopLabel(event); // Breaks same note in EOT bgmCrenelStorm 0xDD4356
+                PrintWait(event.time); // instead just print the wait
+                break;
+            case EventType::LoopEndBegin:
+                PrintByte("GOTO");
+                PrintWord("%s_%u_B%u", g_asmLabel.c_str(), g_agbTrack, loopEndBlockNum);
+                PrintSeqLoopLabel(event);
+                loopEndBlockNum = s_blockNum;
+                break;
+            case EventType::LoopBegin:
+                PrintSeqLoopLabel(event);
+                loopEndBlockNum = s_blockNum;
+                break;
+            case EventType::WholeNoteMark:
+                if (event.param2 & 0x80000000) {
+                    std::fprintf(g_outputFile, "%s_%u_%03lu::\n", g_asmLabel.c_str(), g_agbTrack,
+                                 (unsigned long)(event.param2 & 0x7FFFFFFF));
+                    ResetTrackVars();
+                    s_inPattern = true;
+                }
+                PrintWait(event.time);
+                break;
+            case EventType::Pattern:
+                PrintByte("PATT");
+                PrintWord("%s_%u_%03lu", g_asmLabel.c_str(), g_agbTrack, event.param2);
+
+                while (!IsPatternBoundary(events[i + 1].type))
+                    i++;
 
-            while (!IsPatternBoundary(events[i + 1].type))
-                i++;
-
-            ResetTrackVars();
-            break;
-        case EventType::Tempo:
-            PrintByte("TEMPO , %u*%s_tbs/2", 60000000 / event.param2, g_asmLabel.c_str());
-            PrintWait(event.time);
-            break;
-        case EventType::InstrumentChange:
-            PrintOp(event.time, "VOICE ", "%u", event.param1);
-            break;
-        case EventType::PitchBend:
-            PrintOp(event.time, "BEND  ", "c_v%+d", event.param2 - 64);
-            break;
-        case EventType::Controller:
-            PrintControllerOp(event);
-            break;
-        default:
-            PrintWait(event.time);
-            break;
+                ResetTrackVars();
+                break;
+            case EventType::Tempo:
+                PrintByte("TEMPO , %u*%s_tbs/2", 60000000 / event.param2, g_asmLabel.c_str());
+                PrintWait(event.time);
+                break;
+            case EventType::InstrumentChange:
+                PrintOp(event.time, "VOICE ", "%u", event.param1);
+                break;
+            case EventType::PitchBend:
+                PrintOp(event.time, "BEND  ", "c_v%+d", event.param2 - 64);
+                break;
+            case EventType::Controller:
+                PrintControllerOp(event);
+                break;
+            default:
+                PrintWait(event.time);
+                break;
         }
     }
 
     PrintByte("FINE");
 }
 
-void PrintAgbFooter()
-{
+void PrintAgbFooter() {
     int trackCount = g_agbTrack - 1;
 
     std::fprintf(g_outputFile, "\n@******************************************************@\n");
diff --git a/tools/src/mid2agb/error.cpp b/tools/src/mid2agb/error.cpp
index 13e38ffa..d824ae86 100755..100644
--- a/tools/src/mid2agb/error.cpp
+++ b/tools/src/mid2agb/error.cpp
@@ -23,8 +23,7 @@
 #include <cstdarg>
 
 // Reports an error diagnostic and terminates the program.
-[[noreturn]] void RaiseError(const char* format, ...)
-{
+[[noreturn]] void RaiseError(const char* format, ...) {
     const int bufferSize = 1024;
     char buffer[bufferSize];
     std::va_list args;
diff --git a/tools/src/mid2agb/main.cpp b/tools/src/mid2agb/main.cpp
index ea2b294a..6436b5a1 100755..100644
--- a/tools/src/mid2agb/main.cpp
+++ b/tools/src/mid2agb/main.cpp
@@ -42,52 +42,44 @@ int g_clocksPerBeat = 1;
 bool g_exactGateTime = false;
 bool g_compressionEnabled = true;
 
-[[noreturn]] static void PrintUsage()
-{
-    std::printf(
-        "Usage: MID2AGB name [options]\n"
-        "\n"
-        "    input_file  filename(.mid) of MIDI file\n"
-        "   output_file  filename(.s) for AGB file (default:input_file)\n"
-        "\n"
-        "options  -L???  label for assembler (default:output_file)\n"
-        "         -V???  master volume (default:127)\n"
-        "         -G???  voice group number (default:0)\n"
-        "         -P???  priority (default:0)\n"
-        "         -R???  reverb (default:off)\n"
-        "            -X  48 clocks/beat (default:24 clocks/beat)\n"
-        "            -E  exact gate-time\n"
-        "            -N  no compression\n"
-    );
+[[noreturn]] static void PrintUsage() {
+    std::printf("Usage: MID2AGB name [options]\n"
+                "\n"
+                "    input_file  filename(.mid) of MIDI file\n"
+                "   output_file  filename(.s) for AGB file (default:input_file)\n"
+                "\n"
+                "options  -L???  label for assembler (default:output_file)\n"
+                "         -V???  master volume (default:127)\n"
+                "         -G???  voice group number (default:0)\n"
+                "         -P???  priority (default:0)\n"
+                "         -R???  reverb (default:off)\n"
+                "            -X  48 clocks/beat (default:24 clocks/beat)\n"
+                "            -E  exact gate-time\n"
+                "            -N  no compression\n");
     std::exit(1);
 }
 
-static std::string StripExtension(std::string s)
-{
+static std::string StripExtension(std::string s) {
     std::size_t pos = s.find_last_of('.');
 
-    if (pos > 0 && pos != std::string::npos)
-    {
+    if (pos > 0 && pos != std::string::npos) {
         s = s.substr(0, pos);
     }
 
     return s;
 }
 
-static std::string GetExtension(std::string s)
-{
+static std::string GetExtension(std::string s) {
     std::size_t pos = s.find_last_of('.');
 
-    if (pos > 0 && pos != std::string::npos)
-    {
+    if (pos > 0 && pos != std::string::npos) {
         return s.substr(pos + 1);
     }
 
     return "";
 }
 
-static std::string BaseName(std::string s)
-{
+static std::string BaseName(std::string s) {
     std::size_t posAfterSlash = s.find_last_of("/\\");
 
     if (posAfterSlash == std::string::npos)
@@ -102,11 +94,10 @@ static std::string BaseName(std::string s)
     return s;
 }
 
-static const char *GetArgument(int argc, char **argv, int& index)
-{
+static const char* GetArgument(int argc, char** argv, int& index) {
     assert(index >= 0 && index < argc);
 
-    const char *option = argv[index];
+    const char* option = argv[index];
 
     assert(option != nullptr);
     assert(option[0] == '-');
@@ -116,77 +107,68 @@ static const char *GetArgument(int argc, char **argv, int& index)
         return option + 2;
 
     // Otherwise, try to get the next arg.
-    if (index + 1 < argc)
-    {
+    if (index + 1 < argc) {
         index++;
         return argv[index];
-    }
-    else
-    {
+    } else {
         return nullptr;
     }
 }
 
-int main(int argc, char** argv)
-{
+int main(int argc, char** argv) {
     std::string inputFilename;
     std::string outputFilename;
 
-    for (int i = 1; i < argc; i++)
-    {
-        const char *option = argv[i];
-
-        if (option[0] == '-' && option[1] != '\0')
-        {
-            const char *arg;
-
-            switch (std::toupper(option[1]))
-            {
-            case 'E':
-                g_exactGateTime = true;
-                break;
-            case 'G':
-                arg = GetArgument(argc, argv, i);
-                if (arg == nullptr)
-                    PrintUsage();
-                g_voiceGroup = std::stoi(arg);
-                break;
-            case 'L':
-                arg = GetArgument(argc, argv, i);
-                if (arg == nullptr)
-                    PrintUsage();
-                g_asmLabel = arg;
-                break;
-            case 'N':
-                g_compressionEnabled = false;
-                break;
-            case 'P':
-                arg = GetArgument(argc, argv, i);
-                if (arg == nullptr)
+    for (int i = 1; i < argc; i++) {
+        const char* option = argv[i];
+
+        if (option[0] == '-' && option[1] != '\0') {
+            const char* arg;
+
+            switch (std::toupper(option[1])) {
+                case 'E':
+                    g_exactGateTime = true;
+                    break;
+                case 'G':
+                    arg = GetArgument(argc, argv, i);
+                    if (arg == nullptr)
+                        PrintUsage();
+                    g_voiceGroup = std::stoi(arg);
+                    break;
+                case 'L':
+                    arg = GetArgument(argc, argv, i);
+                    if (arg == nullptr)
+                        PrintUsage();
+                    g_asmLabel = arg;
+                    break;
+                case 'N':
+                    g_compressionEnabled = false;
+                    break;
+                case 'P':
+                    arg = GetArgument(argc, argv, i);
+                    if (arg == nullptr)
+                        PrintUsage();
+                    g_priority = std::stoi(arg);
+                    break;
+                case 'R':
+                    arg = GetArgument(argc, argv, i);
+                    if (arg == nullptr)
+                        PrintUsage();
+                    g_reverb = std::stoi(arg);
+                    break;
+                case 'V':
+                    arg = GetArgument(argc, argv, i);
+                    if (arg == nullptr)
+                        PrintUsage();
+                    g_masterVolume = std::stoi(arg);
+                    break;
+                case 'X':
+                    g_clocksPerBeat = 2;
+                    break;
+                default:
                     PrintUsage();
-                g_priority = std::stoi(arg);
-                break;
-            case 'R':
-                arg = GetArgument(argc, argv, i);
-                if (arg == nullptr)
-                    PrintUsage();
-                g_reverb = std::stoi(arg);
-                break;
-            case 'V':
-                arg = GetArgument(argc, argv, i);
-                if (arg == nullptr)
-                    PrintUsage();
-                g_masterVolume = std::stoi(arg);
-                break;
-            case 'X':
-                g_clocksPerBeat = 2;
-                break;
-            default:
-                PrintUsage();
             }
-        }
-        else
-        {
+        } else {
             if (inputFilename.empty())
                 inputFilename = argv[i];
             else if (outputFilename.empty())
diff --git a/tools/src/mid2agb/midi.cpp b/tools/src/mid2agb/midi.cpp
index d6e7f391..a082fecf 100755..100644
--- a/tools/src/mid2agb/midi.cpp
+++ b/tools/src/mid2agb/midi.cpp
@@ -30,8 +30,7 @@
 #include "agb.h"
 #include "tables.h"
 
-enum class MidiEventCategory
-{
+enum class MidiEventCategory {
     Control,
     SysEx,
     Meta,
@@ -54,20 +53,17 @@ static int s_minNote;
 static int s_maxNote;
 static int s_runningStatus;
 
-void Seek(long offset)
-{
+void Seek(long offset) {
     if (std::fseek(g_inputFile, offset, SEEK_SET) != 0)
         RaiseError("failed to seek to %l", offset);
 }
 
-void Skip(long offset)
-{
+void Skip(long offset) {
     if (std::fseek(g_inputFile, offset, SEEK_CUR) != 0)
         RaiseError("failed to skip %l bytes", offset);
 }
 
-std::string ReadSignature()
-{
+std::string ReadSignature() {
     char signature[4];
 
     if (std::fread(signature, 4, 1, g_inputFile) != 1)
@@ -76,8 +72,7 @@ std::string ReadSignature()
     return std::string(signature, 4);
 }
 
-std::uint32_t ReadInt8()
-{
+std::uint32_t ReadInt8() {
     int c = std::fgetc(g_inputFile);
 
     if (c < 0)
@@ -86,16 +81,14 @@ std::uint32_t ReadInt8()
     return c;
 }
 
-std::uint32_t ReadInt16()
-{
+std::uint32_t ReadInt16() {
     std::uint32_t val = 0;
     val |= ReadInt8() << 8;
     val |= ReadInt8();
     return val;
 }
 
-std::uint32_t ReadInt24()
-{
+std::uint32_t ReadInt24() {
     std::uint32_t val = 0;
     val |= ReadInt8() << 16;
     val |= ReadInt8() << 8;
@@ -103,8 +96,7 @@ std::uint32_t ReadInt24()
     return val;
 }
 
-std::uint32_t ReadInt32()
-{
+std::uint32_t ReadInt32() {
     std::uint32_t val = 0;
     val |= ReadInt8() << 24;
     val |= ReadInt8() << 16;
@@ -113,13 +105,11 @@ std::uint32_t ReadInt32()
     return val;
 }
 
-std::uint32_t ReadVLQ()
-{
+std::uint32_t ReadVLQ() {
     std::uint32_t val = 0;
     std::uint32_t c;
 
-    do
-    {
+    do {
         c = ReadInt8();
         val <<= 7;
         val |= (c & 0x7F);
@@ -128,8 +118,7 @@ std::uint32_t ReadVLQ()
     return val;
 }
 
-void ReadMidiFileHeader()
-{
+void ReadMidiFileHeader() {
     Seek(0);
 
     if (ReadSignature() != "MThd")
@@ -153,8 +142,7 @@ void ReadMidiFileHeader()
         RaiseError("unsupported MIDI time division (%d)", g_midiTimeDiv);
 }
 
-long ReadMidiTrackHeader(long offset)
-{
+long ReadMidiTrackHeader(long offset) {
     Seek(offset);
 
     if (ReadSignature() != "MTrk")
@@ -167,82 +155,65 @@ long ReadMidiTrackHeader(long offset)
     return size + 8;
 }
 
-void StartTrack()
-{
+void StartTrack() {
     Seek(s_trackDataStart);
     s_absoluteTime = 0;
     s_runningStatus = 0;
 }
 
-void SkipEventData()
-{
+void SkipEventData() {
     Skip(ReadVLQ());
 }
 
-void DetermineEventCategory(MidiEventCategory& category, int& typeChan, int& size)
-{
+void DetermineEventCategory(MidiEventCategory& category, int& typeChan, int& size) {
     typeChan = ReadInt8();
 
-    if (typeChan < 0x80)
-    {
+    if (typeChan < 0x80) {
         // If data byte was found, use the running status.
         ungetc(typeChan, g_inputFile);
         typeChan = s_runningStatus;
     }
 
-    if (typeChan == 0xFF)
-    {
+    if (typeChan == 0xFF) {
         category = MidiEventCategory::Meta;
         size = 0;
         s_runningStatus = 0;
-    }
-    else if (typeChan >= 0xF0)
-    {
+    } else if (typeChan >= 0xF0) {
         category = MidiEventCategory::SysEx;
         size = 0;
         s_runningStatus = 0;
-    }
-    else if (typeChan >= 0x80)
-    {
+    } else if (typeChan >= 0x80) {
         category = MidiEventCategory::Control;
 
-        switch (typeChan >> 4)
-        {
-        case 0xC:
-        case 0xD:
-            size = 1;
-            break;
-        default:
-            size = 2;
-            break;
+        switch (typeChan >> 4) {
+            case 0xC:
+            case 0xD:
+                size = 1;
+                break;
+            default:
+                size = 2;
+                break;
         }
         s_runningStatus = typeChan;
-    }
-    else
-    {
+    } else {
         category = MidiEventCategory::Invalid;
     }
 }
 
-void MakeBlockEvent(Event& event, EventType type)
-{
+void MakeBlockEvent(Event& event, EventType type) {
     event.type = type;
     event.param1 = s_blockCount++;
     event.param2 = 0;
 }
 
-std::string ReadEventText()
-{
+std::string ReadEventText() {
     char buffer[2];
     std::uint32_t length = ReadVLQ();
 
-    if (length <= 2)
-    {
+    if (length <= 2) {
         if (fread(buffer, length, 1, g_inputFile) != 1)
             RaiseError("failed to read event text");
-    }
-    else
-    {
+    } else {
         Skip(length);
         length = 0;
     }
@@ -250,8 +221,7 @@ std::string ReadEventText()
     return std::string(buffer, length);
 }
 
-bool ReadSeqEvent(Event& event)
-{
+bool ReadSeqEvent(Event& event) {
     s_absoluteTime += ReadVLQ();
     event.time = s_absoluteTime;
 
@@ -261,14 +231,12 @@ bool ReadSeqEvent(Event& event)
 
     DetermineEventCategory(category, typeChan, size);
 
-    if (category == MidiEventCategory::Control)
-    {
+    if (category == MidiEventCategory::Control) {
         Skip(size);
         return false;
     }
 
-    if (category == MidiEventCategory::SysEx)
-    {
+    if (category == MidiEventCategory::SysEx) {
         SkipEventData();
         return false;
     }
@@ -279,8 +247,7 @@ bool ReadSeqEvent(Event& event)
     // meta event
     int metaEventType = ReadInt8();
 
-    if (metaEventType >= 1 && metaEventType <= 7)
-    {
+    if (metaEventType >= 1 && metaEventType <= 7) {
         // text event
         std::string text = ReadEventText();
 
@@ -294,69 +261,63 @@ bool ReadSeqEvent(Event& event)
             MakeBlockEvent(event, EventType::Label);
         else
             return false;
-    }
-    else
-    {
-        switch (metaEventType)
-        {
-        case 0x2F: // end of track
-            SkipEventData();
-            event.type = EventType::EndOfTrack;
-            event.param1 = 0;
-            event.param2 = 0;
-            break;
-        case 0x51: // tempo
-            if (ReadVLQ() != 3)
-                RaiseError("invalid tempo size");
-
-            event.type = EventType::Tempo;
-            event.param1 = 0;
-            event.param2 = ReadInt24();
-            break;
-        case 0x58: // time signature
-        {
-            if (ReadVLQ() != 4)
-                RaiseError("invalid time signature size");
+    } else {
+        switch (metaEventType) {
+            case 0x2F: // end of track
+                SkipEventData();
+                event.type = EventType::EndOfTrack;
+                event.param1 = 0;
+                event.param2 = 0;
+                break;
+            case 0x51: // tempo
+                if (ReadVLQ() != 3)
+                    RaiseError("invalid tempo size");
+
+                event.type = EventType::Tempo;
+                event.param1 = 0;
+                event.param2 = ReadInt24();
+                break;
+            case 0x58: // time signature
+            {
+                if (ReadVLQ() != 4)
+                    RaiseError("invalid time signature size");
 
-            int numerator = ReadInt8();
-            int denominatorExponent = ReadInt8();
+                int numerator = ReadInt8();
+                int denominatorExponent = ReadInt8();
 
-            if (denominatorExponent >= 16)
-                RaiseError("invalid time signature denominator");
+                if (denominatorExponent >= 16)
+                    RaiseError("invalid time signature denominator");
 
-            Skip(2); // ignore other values
+                Skip(2); // ignore other values
 
-            int clockTicks = 96 * numerator * g_clocksPerBeat;
-            int denominator = 1 << denominatorExponent;
-            int timeSig = clockTicks / denominator;
+                int clockTicks = 96 * numerator * g_clocksPerBeat;
+                int denominator = 1 << denominatorExponent;
+                int timeSig = clockTicks / denominator;
 
-            if (timeSig <= 0 || timeSig >= 0x10000)
-                RaiseError("invalid time signature");
+                if (timeSig <= 0 || timeSig >= 0x10000)
+                    RaiseError("invalid time signature");
 
-            event.type = EventType::TimeSignature;
-            event.param1 = 0;
-            event.param2 = timeSig;
-            break;
-        }
-        default:
-            SkipEventData();
-            return false;
+                event.type = EventType::TimeSignature;
+                event.param1 = 0;
+                event.param2 = timeSig;
+                break;
+            }
+            default:
+                SkipEventData();
+                return false;
         }
     }
 
     return true;
 }
 
-void ReadSeqEvents()
-{
+void ReadSeqEvents() {
     StartTrack();
 
-    for (;;)
-    {
+    for (;;) {
         Event event = {};
 
-        if (ReadSeqEvent(event))
-        {
+        if (ReadSeqEvent(event)) {
             s_seqEvents.push_back(event);
 
             if (event.type == EventType::EndOfTrack)
@@ -365,8 +326,7 @@ void ReadSeqEvents()
     }
 }
 
-bool CheckNoteEnd(Event& event)
-{
+bool CheckNoteEnd(Event& event) {
     event.param2 += ReadVLQ();
 
     MidiEventCategory category;
@@ -375,50 +335,45 @@ bool CheckNoteEnd(Event& event)
 
     DetermineEventCategory(category, typeChan, size);
 
-    if (category == MidiEventCategory::Control)
-    {
+    if (category == MidiEventCategory::Control) {
         int chan = typeChan & 0xF;
 
-        if (chan != g_midiChan)
-        {
+        if (chan != g_midiChan) {
             Skip(size);
             return false;
         }
 
-        switch (typeChan & 0xF0)
-        {
-        case 0x80: // note off
-        {
-            int note = ReadInt8();
-            ReadInt8(); // ignore velocity
-            if (note == event.note)
-                return true;
-            break;
-        }
-        case 0x90: // note on
-        {
-            int note = ReadInt8();
-            int velocity = ReadInt8();
-            if (velocity == 0 && note == event.note)
-                return true;
-            break;
-        }
-        default:
-            Skip(size);
-            break;
+        switch (typeChan & 0xF0) {
+            case 0x80: // note off
+            {
+                int note = ReadInt8();
+                ReadInt8(); // ignore velocity
+                if (note == event.note)
+                    return true;
+                break;
+            }
+            case 0x90: // note on
+            {
+                int note = ReadInt8();
+                int velocity = ReadInt8();
+                if (velocity == 0 && note == event.note)
+                    return true;
+                break;
+            }
+            default:
+                Skip(size);
+                break;
         }
 
         return false;
     }
 
-    if (category == MidiEventCategory::SysEx)
-    {
+    if (category == MidiEventCategory::SysEx) {
         SkipEventData();
         return false;
     }
 
-    if (category == MidiEventCategory::Meta)
-    {
+    if (category == MidiEventCategory::Meta) {
         int metaEventType = ReadInt8();
         SkipEventData();
 
@@ -431,8 +386,7 @@ bool CheckNoteEnd(Event& event)
     RaiseError("invalid event");
 }
 
-void FindNoteEnd(Event& event)
-{
+void FindNoteEnd(Event& event) {
     // Save the current file position and running status
     // which get modified by CheckNoteEnd.
     long startPos = ftell(g_inputFile);
@@ -447,8 +401,7 @@ void FindNoteEnd(Event& event)
     s_runningStatus = savedRunningStatus;
 }
 
-bool ReadTrackEvent(Event& event)
-{
+bool ReadTrackEvent(Event& event) {
     s_absoluteTime += ReadVLQ();
     event.time = s_absoluteTime;
 
@@ -458,74 +411,66 @@ bool ReadTrackEvent(Event& event)
 
     DetermineEventCategory(category, typeChan, size);
 
-    if (category == MidiEventCategory::Control)
-    {
+    if (category == MidiEventCategory::Control) {
         int chan = typeChan & 0xF;
 
-        if (chan != g_midiChan)
-        {
+        if (chan != g_midiChan) {
             Skip(size);
             return false;
         }
 
-        switch (typeChan & 0xF0)
-        {
-        case 0x90: // note on
-        {
-            int note = ReadInt8();
-            int velocity = ReadInt8();
-
-            if (velocity != 0)
+        switch (typeChan & 0xF0) {
+            case 0x90: // note on
             {
-                event.type = EventType::Note;
-                event.note = note;
-                event.param1 = velocity;
-                FindNoteEnd(event);
-                if (event.param2 > 0)
-                {
-                    if (note < s_minNote)
-                        s_minNote = note;
-                    if (note > s_maxNote)
-                        s_maxNote = note;
+                int note = ReadInt8();
+                int velocity = ReadInt8();
+
+                if (velocity != 0) {
+                    event.type = EventType::Note;
+                    event.note = note;
+                    event.param1 = velocity;
+                    FindNoteEnd(event);
+                    if (event.param2 > 0) {
+                        if (note < s_minNote)
+                            s_minNote = note;
+                        if (note > s_maxNote)
+                            s_maxNote = note;
+                    }
                 }
+                break;
             }
-            break;
-        }
-        case 0xB0: // controller event
-            event.type = EventType::Controller;
-            event.param1 = ReadInt8(); // controller index
-            event.param2 = ReadInt8(); // value
-            break;
-        case 0xC0: // instrument change
-            event.type = EventType::InstrumentChange;
-            event.param1 = ReadInt8(); // instrument
-            event.param2 = 0;
-            break;
-        case 0xE0: // pitch bend
-            event.type = EventType::PitchBend;
-            event.param1 = ReadInt8();
-            event.param2 = ReadInt8();
-            break;
-        default:
-            Skip(size);
-            return false;
+            case 0xB0: // controller event
+                event.type = EventType::Controller;
+                event.param1 = ReadInt8(); // controller index
+                event.param2 = ReadInt8(); // value
+                break;
+            case 0xC0: // instrument change
+                event.type = EventType::InstrumentChange;
+                event.param1 = ReadInt8(); // instrument
+                event.param2 = 0;
+                break;
+            case 0xE0: // pitch bend
+                event.type = EventType::PitchBend;
+                event.param1 = ReadInt8();
+                event.param2 = ReadInt8();
+                break;
+            default:
+                Skip(size);
+                return false;
         }
 
         return true;
     }
 
-    if (category == MidiEventCategory::SysEx)
-    {
+    if (category == MidiEventCategory::SysEx) {
         SkipEventData();
         return false;
     }
 
-    if (category == MidiEventCategory::Meta)
-    {
+    if (category == MidiEventCategory::Meta) {
         int metaEventType = ReadInt8();
 
-        if (metaEventType >= 1 && metaEventType <= 7)
-        {
+        if (metaEventType >= 1 && metaEventType <= 7) {
             // text event
             std::string text = ReadEventText();
 
@@ -540,17 +485,13 @@ bool ReadTrackEvent(Event& event)
             else
                 return false;
             return true;
-        }
-        else if (metaEventType == 0x2F)
-        {
+        } else if (metaEventType == 0x2F) {
             SkipEventData();
             event.type = EventType::EndOfTrack;
             event.param1 = 0;
             event.param2 = 0;
             return true;
-        }
-        else
-        {
+        } else {
             SkipEventData();
         }
 
@@ -560,8 +501,7 @@ bool ReadTrackEvent(Event& event)
     RaiseError("invalid event");
 }
 
-void ReadTrackEvents()
-{
+void ReadTrackEvents() {
     StartTrack();
 
     s_trackEvents.clear();
@@ -569,12 +509,10 @@ void ReadTrackEvents()
     s_minNote = 0xFF;
     s_maxNote = 0;
 
-    for (;;)
-    {
+    for (;;) {
         Event event = {};
 
-        if (ReadTrackEvent(event))
-        {
+        if (ReadTrackEvent(event)) {
             s_trackEvents.push_back(event);
 
             if (event.type == EventType::EndOfTrack)
@@ -583,8 +521,7 @@ void ReadTrackEvents()
     }
 }
 
-bool EventCompare(const Event& event1, const Event& event2)
-{
+bool EventCompare(const Event& event1, const Event& event2) {
     if (event1.time < event2.time)
         return true;
 
@@ -606,8 +543,7 @@ bool EventCompare(const Event& event1, const Event& event2)
     if (event1Type > event2Type)
         return false;
 
-    if (event1.type == EventType::EndOfTie)
-    {
+    if (event1.type == EventType::EndOfTie) {
         if (event1.note < event2.note)
             return true;
 
@@ -618,16 +554,14 @@ bool EventCompare(const Event& event1, const Event& event2)
     return false;
 }
 
-std::unique_ptr<std::vector<Event>> MergeEvents()
-{
+std::unique_ptr<std::vector<Event>> MergeEvents() {
     std::unique_ptr<std::vector<Event>> events(new std::vector<Event>());
 
     unsigned trackEventPos = 0;
     unsigned seqEventPos = 0;
 
-    while (s_trackEvents[trackEventPos].type != EventType::EndOfTrack
-        && s_seqEvents[seqEventPos].type != EventType::EndOfTrack)
-    {
+    while (s_trackEvents[trackEventPos].type != EventType::EndOfTrack &&
+           s_seqEvents[seqEventPos].type != EventType::EndOfTrack) {
         if (EventCompare(s_trackEvents[trackEventPos], s_seqEvents[seqEventPos]))
             events->push_back(s_trackEvents[trackEventPos++]);
         else
@@ -649,14 +583,11 @@ std::unique_ptr<std::vector<Event>> MergeEvents()
     return events;
 }
 
-void ConvertTimes(std::vector<Event>& events)
-{
-    for (Event& event : events)
-    {
+void ConvertTimes(std::vector<Event>& events) {
+    for (Event& event : events) {
         event.time = (24 * g_clocksPerBeat * event.time) / g_midiTimeDiv;
 
-        if (event.type == EventType::Note)
-        {
+        if (event.type == EventType::Note) {
             event.param1 = g_noteVelocityLUT[event.param1];
 
             std::uint32_t duration = (24 * g_clocksPerBeat * event.param2) / g_midiTimeDiv;
@@ -682,8 +613,7 @@ void insertAtCorrectTimeFromEnd(const std::unique_ptr<std::vector<Event>>& event
     events->insert(events->begin(), event);
 }
 
-std::unique_ptr<std::vector<Event>> InsertTimingEvents(std::vector<Event>& inEvents)
-{
+std::unique_ptr<std::vector<Event>> InsertTimingEvents(std::vector<Event>& inEvents) {
     std::unique_ptr<std::vector<Event>> outEvents(new std::vector<Event>());
 
     Event timingEvent = {};
@@ -691,18 +621,14 @@ std::unique_ptr<std::vector<Event>> InsertTimingEvents(std::vector<Event>& inEve
     timingEvent.type = EventType::TimeSignature;
     timingEvent.param2 = 96 * g_clocksPerBeat;
 
-    for (const Event& event : inEvents)
-    {
-        while (EventCompare(timingEvent, event))
-        {
+    for (const Event& event : inEvents) {
+        while (EventCompare(timingEvent, event)) {
             outEvents->push_back(timingEvent);
             timingEvent.time += timingEvent.param2;
         }
 
-        if (event.type == EventType::TimeSignature)
-        {
-            if (g_agbTrack == 1 && event.param2 != timingEvent.param2)
-            {
+        if (event.type == EventType::TimeSignature) {
+            if (g_agbTrack == 1 && event.param2 != timingEvent.param2) {
                 Event originalTimingEvent = event;
                 originalTimingEvent.type = EventType::OriginalTimeSignature;
                 outEvents->push_back(originalTimingEvent);
@@ -717,23 +643,19 @@ std::unique_ptr<std::vector<Event>> InsertTimingEvents(std::vector<Event>& inEve
     return outEvents;
 }
 
-std::unique_ptr<std::vector<Event>> SplitTime(std::vector<Event>& inEvents)
-{
+std::unique_ptr<std::vector<Event>> SplitTime(std::vector<Event>& inEvents) {
     std::unique_ptr<std::vector<Event>> outEvents(new std::vector<Event>());
 
     std::int32_t time = 0;
 
-    for (const Event& event : inEvents)
-    {
+    for (const Event& event : inEvents) {
         std::int32_t diff = event.time - time;
 
-        if (diff > 96)
-        {
+        if (diff > 96) {
             int wholeNoteCount = (diff - 1) / 96;
             diff -= 96 * wholeNoteCount;
 
-            for (int i = 0; i < wholeNoteCount; i++)
-            {
+            for (int i = 0; i < wholeNoteCount; i++) {
                 time += 96;
                 Event timeSplitEvent = {};
                 timeSplitEvent.time = time;
@@ -744,8 +666,7 @@ std::unique_ptr<std::vector<Event>> SplitTime(std::vector<Event>& inEvents)
 
         std::int32_t lutValue = g_noteDurationLUT[diff];
 
-        if (lutValue != diff)
-        {
+        if (lutValue != diff) {
             Event timeSplitEvent = {};
             timeSplitEvent.time = time + lutValue;
             timeSplitEvent.type = EventType::TimeSplit;
@@ -760,14 +681,11 @@ std::unique_ptr<std::vector<Event>> SplitTime(std::vector<Event>& inEvents)
     return outEvents;
 }
 
-std::unique_ptr<std::vector<Event>> CreateTies(std::vector<Event>& inEvents)
-{
+std::unique_ptr<std::vector<Event>> CreateTies(std::vector<Event>& inEvents) {
     std::unique_ptr<std::vector<Event>> outEvents(new std::vector<Event>());
 
-    for (const Event& event : inEvents)
-    {
-        if (event.type == EventType::Note && event.param2 > 96)
-        {
+    for (const Event& event : inEvents) {
+        if (event.type == EventType::Note && event.param2 > 96) {
             Event tieEvent = event;
             tieEvent.param2 = -1;
             insertAtCorrectTimeFromEnd(outEvents, tieEvent);
@@ -779,9 +697,7 @@ std::unique_ptr<std::vector<Event>> CreateTies(std::vector<Event>& inEvents)
             // directly insert at the correct position, so it does not need to be sorted later.
             // TODO rather keep eotEvent in queue until it's time is reached?
             insertAtCorrectTimeFromEnd(outEvents, eotEvent);
-        }
-        else
-        {
+        } else {
             insertAtCorrectTimeFromEnd(outEvents, event);
         }
     }
@@ -789,25 +705,21 @@ std::unique_ptr<std::vector<Event>> CreateTies(std::vector<Event>& inEvents)
     return outEvents;
 }
 
-void CalculateWaits(std::vector<Event>& events)
-{
+void CalculateWaits(std::vector<Event>& events) {
     g_initialWait = events[0].time;
     int wholeNoteCount = 0;
 
-    for (unsigned i = 0; i < events.size() && events[i].type != EventType::EndOfTrack; i++)
-    {
+    for (unsigned i = 0; i < events.size() && events[i].type != EventType::EndOfTrack; i++) {
         events[i].time = events[i + 1].time - events[i].time;
 
-        if (events[i].type == EventType::TimeSignature)
-        {
+        if (events[i].type == EventType::TimeSignature) {
             events[i].type = EventType::WholeNoteMark;
             events[i].param2 = wholeNoteCount++;
         }
     }
 }
 
-int CalculateCompressionScore(std::vector<Event>& events, int index)
-{
+int CalculateCompressionScore(std::vector<Event>& events, int index) {
     int score = 0;
     std::uint8_t lastParam1 = events[index].param1;
     std::uint8_t lastVelocity = 0x80u;
@@ -818,28 +730,23 @@ int CalculateCompressionScore(std::vector<Event>& events, int index)
     if (events[index].time > 0)
         score++;
 
-    for (int i = index + 1; !IsPatternBoundary(events[i].type); i++)
-    {
-        if (events[i].type == EventType::Note)
-        {
+    for (int i = index + 1; !IsPatternBoundary(events[i].type); i++) {
+        if (events[i].type == EventType::Note) {
             int val = 0;
 
-            if (events[i].note != lastNote)
-            {
+            if (events[i].note != lastNote) {
                 val++;
                 lastNote = events[i].note;
             }
 
-            if (events[i].param1 != lastVelocity)
-            {
+            if (events[i].param1 != lastVelocity) {
                 val++;
                 lastVelocity = events[i].param1;
             }
 
             std::int32_t duration = events[i].param2;
 
-            if (g_noteDurationLUT[duration] != lastDuration)
-            {
+            if (g_noteDurationLUT[duration] != lastDuration) {
                 val++;
                 lastDuration = g_noteDurationLUT[duration];
             }
@@ -851,24 +758,17 @@ int CalculateCompressionScore(std::vector<Event>& events, int index)
                 val = 1;
 
             score += val;
-        }
-        else
-        {
+        } else {
             lastDuration = 0x80000000;
 
-            if (events[i].type == lastType)
-            {
-                if ((lastType != EventType::Controller && (int)lastType != 0x25 && lastType != EventType::EndOfTie) || events[i].param1 == lastParam1)
-                {
+            if (events[i].type == lastType) {
+                if ((lastType != EventType::Controller && (int)lastType != 0x25 && lastType != EventType::EndOfTie) ||
+                    events[i].param1 == lastParam1) {
                     score++;
-                }
-                else
-                {
+                } else {
                     score += 2;
                 }
-            }
-            else
-            {
+            } else {
                 score += 2;
             }
         }
@@ -883,19 +783,15 @@ int CalculateCompressionScore(std::vector<Event>& events, int index)
     return score;
 }
 
-bool IsCompressionMatch(std::vector<Event>& events, int index1, int index2)
-{
-    if (events[index1].type != events[index2].type ||
-        events[index1].note != events[index2].note ||
-        events[index1].param1 != events[index2].param1 ||
-        events[index1].time != events[index2].time)
+bool IsCompressionMatch(std::vector<Event>& events, int index1, int index2) {
+    if (events[index1].type != events[index2].type || events[index1].note != events[index2].note ||
+        events[index1].param1 != events[index2].param1 || events[index1].time != events[index2].time)
         return false;
 
     index1++;
     index2++;
 
-    do
-    {
+    do {
         if (events[index1] != events[index2])
             return false;
 
@@ -906,20 +802,16 @@ bool IsCompressionMatch(std::vector<Event>& events, int index1, int index2)
     return IsPatternBoundary(events[index2].type);
 }
 
-void CompressWholeNote(std::vector<Event>& events, int index)
-{
-    for (int j = index + 1; events[j].type != EventType::EndOfTrack; j++)
-    {
-        while (events[j].type != EventType::WholeNoteMark)
-        {
+void CompressWholeNote(std::vector<Event>& events, int index) {
+    for (int j = index + 1; events[j].type != EventType::EndOfTrack; j++) {
+        while (events[j].type != EventType::WholeNoteMark) {
             j++;
 
             if (events[j].type == EventType::EndOfTrack)
                 return;
         }
 
-        if (IsCompressionMatch(events, index, j))
-        {
+        if (IsCompressionMatch(events, index, j)) {
             events[j].type = EventType::Pattern;
             events[j].param2 = events[index].param2 & 0x7FFFFFFF;
             events[index].param2 |= 0x80000000;
@@ -927,27 +819,22 @@ void CompressWholeNote(std::vector<Event>& events, int index)
     }
 }
 
-void Compress(std::vector<Event>& events)
-{
-    for (int i = 0; events[i].type != EventType::EndOfTrack; i++)
-    {
-        while (events[i].type != EventType::WholeNoteMark)
-        {
+void Compress(std::vector<Event>& events) {
+    for (int i = 0; events[i].type != EventType::EndOfTrack; i++) {
+        while (events[i].type != EventType::WholeNoteMark) {
             i++;
 
             if (events[i].type == EventType::EndOfTrack)
                 return;
         }
 
-        if (CalculateCompressionScore(events, i) >= 6)
-        {
+        if (CalculateCompressionScore(events, i) >= 6) {
             CompressWholeNote(events, i);
         }
     }
 }
 
-void ReadMidiTracks()
-{
+void ReadMidiTracks() {
     long trackHeaderStart = 14;
 
     ReadMidiTrackHeader(trackHeaderStart);
@@ -955,16 +842,13 @@ void ReadMidiTracks()
 
     g_agbTrack = 1;
 
-    for (int midiTrack = 0; midiTrack < g_midiTrackCount; midiTrack++)
-    {
+    for (int midiTrack = 0; midiTrack < g_midiTrackCount; midiTrack++) {
         trackHeaderStart += ReadMidiTrackHeader(trackHeaderStart);
 
-        for (g_midiChan = 0; g_midiChan < 16; g_midiChan++)
-        {
+        for (g_midiChan = 0; g_midiChan < 16; g_midiChan++) {
             ReadTrackEvents();
 
-            if (s_minNote != 0xFF)
-            {
+            if (s_minNote != 0xFF) {
 #ifdef DEBUG
                 printf("Track%d = Midi-Ch.%d\n", g_agbTrack, g_midiChan + 1);
 #endif
@@ -972,9 +856,9 @@ void ReadMidiTracks()
                 std::unique_ptr<std::vector<Event>> events(MergeEvents());
 
                 // We don't need TEMPO in anything but track 1.
-                if (g_agbTrack == 1)
-                {
-                    auto it = std::remove_if(s_seqEvents.begin(), s_seqEvents.end(), [](const Event& event) { return event.type == EventType::Tempo; });
+                if (g_agbTrack == 1) {
+                    auto it = std::remove_if(s_seqEvents.begin(), s_seqEvents.end(),
+                                             [](const Event& event) { return event.type == EventType::Tempo; });
                     s_seqEvents.erase(it, s_seqEvents.end());
                 }
 
diff --git a/tools/src/mid2agb/midi.h b/tools/src/mid2agb/midi.h
index 28c98f8f..5cfd1458 100755..100644
--- a/tools/src/mid2agb/midi.h
+++ b/tools/src/mid2agb/midi.h
@@ -23,14 +23,9 @@
 
 #include <cstdint>
 
-enum class MidiFormat
-{
-    SingleTrack,
-    MultiTrack
-};
+enum class MidiFormat { SingleTrack, MultiTrack };
 
-enum class EventType
-{
+enum class EventType {
     EndOfTie = 0x01,
     Label = 0x11,
     LoopEnd = 0x38, // To place it last if at the same time as other meta events, but before notes on the same frame
@@ -50,25 +45,19 @@ enum class EventType
     EndOfTrack = 0xFF,
 };
 
-struct Event
-{
+struct Event {
     std::int32_t time;
     EventType type;
     std::uint8_t note;
     std::uint8_t param1;
     std::int32_t param2;
 
-    bool operator==(const Event& other)
-    {
-        return (time == other.time
-            && type == other.type
-            && note == other.note
-            && param1 == other.param1
-            && param2 == other.param2);
+    bool operator==(const Event& other) {
+        return (time == other.time && type == other.type && note == other.note && param1 == other.param1 &&
+                param2 == other.param2);
     }
 
-    bool operator!=(const Event& other)
-    {
+    bool operator!=(const Event& other) {
         return !(*this == other);
     }
 };
@@ -79,8 +68,7 @@ void ReadMidiTracks();
 extern int g_midiChan;
 extern std::int32_t g_initialWait;
 
-inline bool IsPatternBoundary(EventType type)
-{
+inline bool IsPatternBoundary(EventType type) {
     return type == EventType::EndOfTrack || (int)type <= 0x17;
 }
 
diff --git a/tools/src/mid2agb/tables.cpp b/tools/src/mid2agb/tables.cpp
index f254664a..f30f37c8 100755..100644
--- a/tools/src/mid2agb/tables.cpp
+++ b/tools/src/mid2agb/tables.cpp
@@ -20,18 +20,17 @@
 
 #include "tables.h"
 
-const int g_noteDurationLUT[] =
-{
-    0, // 0
-    1, // 1
-    2, // 2
-    3, // 3
-    4, // 4
-    5, // 5
-    6, // 6
-    7, // 7
-    8, // 8
-    9, // 9
+const int g_noteDurationLUT[] = {
+    0,  // 0
+    1,  // 1
+    2,  // 2
+    3,  // 3
+    4,  // 4
+    5,  // 5
+    6,  // 6
+    7,  // 7
+    8,  // 8
+    9,  // 9
     10, // 10
     11, // 11
     12, // 12
@@ -121,105 +120,104 @@ const int g_noteDurationLUT[] =
     96, // 96
 };
 
-const int g_noteVelocityLUT[] =
-{
-    0, // 0
-    4, // 1
-    4, // 2
-    4, // 3
-    4, // 4
-    8, // 5
-    8, // 6
-    8, // 7
-    8, // 8
-    12, // 9
-    12, // 10
-    12, // 11
-    12, // 12
-    16, // 13
-    16, // 14
-    16, // 15
-    16, // 16
-    20, // 17
-    20, // 18
-    20, // 19
-    20, // 20
-    24, // 21
-    24, // 22
-    24, // 23
-    24, // 24
-    28, // 25
-    28, // 26
-    28, // 27
-    28, // 28
-    32, // 29
-    32, // 30
-    32, // 31
-    32, // 32
-    36, // 33
-    36, // 34
-    36, // 35
-    36, // 36
-    40, // 37
-    40, // 38
-    40, // 39
-    40, // 40
-    44, // 41
-    44, // 42
-    44, // 43
-    44, // 44
-    48, // 45
-    48, // 46
-    48, // 47
-    48, // 48
-    52, // 49
-    52, // 50
-    52, // 51
-    52, // 52
-    56, // 53
-    56, // 54
-    56, // 55
-    56, // 56
-    60, // 57
-    60, // 58
-    60, // 59
-    60, // 60
-    64, // 61
-    64, // 62
-    64, // 63
-    64, // 64
-    68, // 65
-    68, // 66
-    68, // 67
-    68, // 68
-    72, // 69
-    72, // 70
-    72, // 71
-    72, // 72
-    76, // 73
-    76, // 74
-    76, // 75
-    76, // 76
-    80, // 77
-    80, // 78
-    80, // 79
-    80, // 80
-    84, // 81
-    84, // 82
-    84, // 83
-    84, // 84
-    88, // 85
-    88, // 86
-    88, // 87
-    88, // 88
-    92, // 89
-    92, // 90
-    92, // 91
-    92, // 92
-    96, // 93
-    96, // 94
-    96, // 95
-    96, // 96
+const int g_noteVelocityLUT[] = {
+    0,   // 0
+    4,   // 1
+    4,   // 2
+    4,   // 3
+    4,   // 4
+    8,   // 5
+    8,   // 6
+    8,   // 7
+    8,   // 8
+    12,  // 9
+    12,  // 10
+    12,  // 11
+    12,  // 12
+    16,  // 13
+    16,  // 14
+    16,  // 15
+    16,  // 16
+    20,  // 17
+    20,  // 18
+    20,  // 19
+    20,  // 20
+    24,  // 21
+    24,  // 22
+    24,  // 23
+    24,  // 24
+    28,  // 25
+    28,  // 26
+    28,  // 27
+    28,  // 28
+    32,  // 29
+    32,  // 30
+    32,  // 31
+    32,  // 32
+    36,  // 33
+    36,  // 34
+    36,  // 35
+    36,  // 36
+    40,  // 37
+    40,  // 38
+    40,  // 39
+    40,  // 40
+    44,  // 41
+    44,  // 42
+    44,  // 43
+    44,  // 44
+    48,  // 45
+    48,  // 46
+    48,  // 47
+    48,  // 48
+    52,  // 49
+    52,  // 50
+    52,  // 51
+    52,  // 52
+    56,  // 53
+    56,  // 54
+    56,  // 55
+    56,  // 56
+    60,  // 57
+    60,  // 58
+    60,  // 59
+    60,  // 60
+    64,  // 61
+    64,  // 62
+    64,  // 63
+    64,  // 64
+    68,  // 65
+    68,  // 66
+    68,  // 67
+    68,  // 68
+    72,  // 69
+    72,  // 70
+    72,  // 71
+    72,  // 72
+    76,  // 73
+    76,  // 74
+    76,  // 75
+    76,  // 76
+    80,  // 77
+    80,  // 78
+    80,  // 79
+    80,  // 80
+    84,  // 81
+    84,  // 82
+    84,  // 83
+    84,  // 84
+    88,  // 85
+    88,  // 86
+    88,  // 87
+    88,  // 88
+    92,  // 89
+    92,  // 90
+    92,  // 91
+    92,  // 92
+    96,  // 93
+    96,  // 94
+    96,  // 95
+    96,  // 96
     100, // 97
     100, // 98
     100, // 99
@@ -253,34 +251,12 @@ const int g_noteVelocityLUT[] =
     127, // 127
 };
 
-const char* g_noteTable[] =
-{
-    "Cn%01u ",
-    "Cs%01u ",
-    "Dn%01u ",
-    "Ds%01u ",
-    "En%01u ",
-    "Fn%01u ",
-    "Fs%01u ",
-    "Gn%01u ",
-    "Gs%01u ",
-    "An%01u ",
-    "As%01u ",
-    "Bn%01u ",
+const char* g_noteTable[] = {
+    "Cn%01u ", "Cs%01u ", "Dn%01u ", "Ds%01u ", "En%01u ", "Fn%01u ",
+    "Fs%01u ", "Gn%01u ", "Gs%01u ", "An%01u ", "As%01u ", "Bn%01u ",
 };
 
-const char* g_minusNoteTable[] =
-{
-    "CnM%01u",
-    "CsM%01u",
-    "DnM%01u",
-    "DsM%01u",
-    "EnM%01u",
-    "FnM%01u",
-    "FsM%01u",
-    "GnM%01u",
-    "GsM%01u",
-    "AnM%01u",
-    "AsM%01u",
-    "BnM%01u",
+const char* g_minusNoteTable[] = {
+    "CnM%01u", "CsM%01u", "DnM%01u", "DsM%01u", "EnM%01u", "FnM%01u",
+    "FsM%01u", "GnM%01u", "GsM%01u", "AnM%01u", "AsM%01u", "BnM%01u",
 };
diff --git a/tools/src/preproc/asm_file.cpp b/tools/src/preproc/asm_file.cpp
index 213a5135..30d6758f 100755..100644
--- a/tools/src/preproc/asm_file.cpp
+++ b/tools/src/preproc/asm_file.cpp
@@ -27,9 +27,8 @@
 #include "utf8.h"
 #include "string_parser.h"
 
-AsmFile::AsmFile(std::string filename) : m_filename(filename)
-{
-    FILE *fp = std::fopen(filename.c_str(), "rb");
+AsmFile::AsmFile(std::string filename) : m_filename(filename) {
+    FILE* fp = std::fopen(filename.c_str(), "rb");
 
     if (fp == NULL) {
         // The include might be an asset.
@@ -64,8 +63,7 @@ AsmFile::AsmFile(std::string filename) : m_filename(filename)
     RemoveComments();
 }
 
-AsmFile::AsmFile(AsmFile&& other) : m_filename(std::move(other.m_filename))
-{
+AsmFile::AsmFile(AsmFile&& other) : m_filename(std::move(other.m_filename)) {
     m_buffer = other.m_buffer;
     m_pos = other.m_pos;
     m_size = other.m_size;
@@ -75,8 +73,7 @@ AsmFile::AsmFile(AsmFile&& other) : m_filename(std::move(other.m_filename))
     other.m_buffer = nullptr;
 }
 
-AsmFile::~AsmFile()
-{
+AsmFile::~AsmFile() {
     delete[] m_buffer;
 }
 
@@ -84,60 +81,44 @@ AsmFile::~AsmFile()
 // It stops upon encountering a null character,
 // which may or may not be the end of file marker.
 // If it's not, the error will be caught later.
-void AsmFile::RemoveComments()
-{
+void AsmFile::RemoveComments() {
     long pos = 0;
     char stringChar = 0;
 
-    for (;;)
-    {
+    for (;;) {
         if (m_buffer[pos] == 0)
             return;
 
-        if (stringChar != 0)
-        {
-            if (m_buffer[pos] == '\\' && m_buffer[pos + 1] == stringChar)
-            {
+        if (stringChar != 0) {
+            if (m_buffer[pos] == '\\' && m_buffer[pos + 1] == stringChar) {
                 pos += 2;
-            }
-            else
-            {
+            } else {
                 if (m_buffer[pos] == stringChar)
                     stringChar = 0;
                 pos++;
             }
-        }
-        else if (m_buffer[pos] == '@' && (pos == 0 || m_buffer[pos - 1] != '\\'))
-        {
+        } else if (m_buffer[pos] == '@' && (pos == 0 || m_buffer[pos - 1] != '\\')) {
             while (m_buffer[pos] != '\n' && m_buffer[pos] != 0)
                 m_buffer[pos++] = ' ';
-        }
-        else if (m_buffer[pos] == '/' && m_buffer[pos + 1] == '*')
-        {
+        } else if (m_buffer[pos] == '/' && m_buffer[pos + 1] == '*') {
             m_buffer[pos++] = ' ';
             m_buffer[pos++] = ' ';
 
-            for (;;)
-            {
+            for (;;) {
                 if (m_buffer[pos] == 0)
                     return;
 
-                if (m_buffer[pos] == '*' && m_buffer[pos + 1] == '/')
-                {
+                if (m_buffer[pos] == '*' && m_buffer[pos + 1] == '/') {
                     m_buffer[pos++] = ' ';
                     m_buffer[pos++] = ' ';
                     break;
-                }
-                else
-                {
+                } else {
                     if (m_buffer[pos] != '\n')
                         m_buffer[pos] = ' ';
                     pos++;
                 }
             }
-        }
-        else
-        {
+        } else {
             if (m_buffer[pos] == '"' || m_buffer[pos] == '\'')
                 stringChar = m_buffer[pos];
             pos++;
@@ -147,8 +128,7 @@ void AsmFile::RemoveComments()
 
 // Checks if we're at a particular directive and if so, consumes it.
 // Returns whether the directive was found.
-bool AsmFile::CheckForDirective(std::string name)
-{
+bool AsmFile::CheckForDirective(std::string name) {
     long i;
     long length = static_cast<long>(name.length());
 
@@ -166,8 +146,7 @@ bool AsmFile::CheckForDirective(std::string name)
 
 // Checks if we're at a known directive and if so, consumes it.
 // Returns which directive was found.
-Directive AsmFile::GetDirective()
-{
+Directive AsmFile::GetDirective() {
     SkipWhitespace();
 
     if (CheckForDirective(".include"))
@@ -182,21 +161,18 @@ Directive AsmFile::GetDirective()
 
 // Checks if we're at label that ends with '::'.
 // Returns the name if so and an empty string if not.
-std::string AsmFile::GetGlobalLabel()
-{
+std::string AsmFile::GetGlobalLabel() {
     long start = m_pos;
     long pos = m_pos;
 
-    if (IsIdentifierStartingChar(m_buffer[pos]))
-    {
+    if (IsIdentifierStartingChar(m_buffer[pos])) {
         pos++;
 
         while (IsIdentifierChar(m_buffer[pos]))
             pos++;
     }
 
-    if (m_buffer[pos] == ':' && m_buffer[pos + 1] == ':')
-    {
+    if (m_buffer[pos] == ':' && m_buffer[pos + 1] == ':') {
         m_pos = pos + 2;
         ExpectEmptyRestOfLine();
         return std::string(&m_buffer[start], pos - start);
@@ -206,15 +182,13 @@ std::string AsmFile::GetGlobalLabel()
 }
 
 // Skips tabs and spaces.
-void AsmFile::SkipWhitespace()
-{
+void AsmFile::SkipWhitespace() {
     while (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' ')
         m_pos++;
 }
 
 // Reads include path.
-std::string AsmFile::ReadPath()
-{
+std::string AsmFile::ReadPath() {
     SkipWhitespace();
 
     if (m_buffer[m_pos] != '"')
@@ -225,12 +199,10 @@ std::string AsmFile::ReadPath()
     int length = 0;
     long startPos = m_pos;
 
-    while (m_buffer[m_pos] != '"')
-    {
+    while (m_buffer[m_pos] != '"') {
         unsigned char c = m_buffer[m_pos++];
 
-        if (c == 0)
-        {
+        if (c == 0) {
             if (m_pos >= m_size)
                 RaiseError("unexpected EOF in include string");
             else
@@ -241,8 +213,7 @@ std::string AsmFile::ReadPath()
             RaiseError("unexpected character '\\x%02X' in include string", c);
 
         // Don't bother allowing any escape sequences.
-        if (c == '\\')
-        {
+        if (c == '\\') {
             c = m_buffer[m_pos];
             RaiseError("unexpected escape '\\%c' in include string", c);
         }
@@ -261,31 +232,23 @@ std::string AsmFile::ReadPath()
 }
 
 // Reads a charmap string.
-int AsmFile::ReadString(unsigned char* s)
-{
+int AsmFile::ReadString(unsigned char* s) {
     SkipWhitespace();
 
     int length;
     StringParser stringParser(m_buffer, m_size);
 
-    try
-    {
+    try {
         m_pos += stringParser.ParseString(m_pos, s, length);
-    }
-    catch (std::runtime_error& e)
-    {
-        RaiseError(e.what());
-    }
+    } catch (std::runtime_error& e) { RaiseError(e.what()); }
 
     SkipWhitespace();
 
-    if (ConsumeComma())
-    {
+    if (ConsumeComma()) {
         SkipWhitespace();
         int padLength = ReadPadLength();
 
-        while (length < padLength)
-        {
+        while (length < padLength) {
             s[length++] = 0;
         }
     }
@@ -295,40 +258,13 @@ int AsmFile::ReadString(unsigned char* s)
     return length;
 }
 
-int AsmFile::ReadBraille(unsigned char* s)
-{
-    static std::map<char, unsigned char> encoding =
-    {
-        { 'A', 0x01 },
-        { 'B', 0x05 },
-        { 'C', 0x03 },
-        { 'D', 0x0B },
-        { 'E', 0x09 },
-        { 'F', 0x07 },
-        { 'G', 0x0F },
-        { 'H', 0x0D },
-        { 'I', 0x06 },
-        { 'J', 0x0E },
-        { 'K', 0x11 },
-        { 'L', 0x15 },
-        { 'M', 0x13 },
-        { 'N', 0x1B },
-        { 'O', 0x19 },
-        { 'P', 0x17 },
-        { 'Q', 0x1F },
-        { 'R', 0x1D },
-        { 'S', 0x16 },
-        { 'T', 0x1E },
-        { 'U', 0x31 },
-        { 'V', 0x35 },
-        { 'W', 0x2E },
-        { 'X', 0x33 },
-        { 'Y', 0x3B },
-        { 'Z', 0x39 },
-        { ' ', 0x00 },
-        { ',', 0x04 },
-        { '.', 0x2C },
-        { '$', 0xFF },
+int AsmFile::ReadBraille(unsigned char* s) {
+    static std::map<char, unsigned char> encoding = {
+        { 'A', 0x01 }, { 'B', 0x05 }, { 'C', 0x03 }, { 'D', 0x0B }, { 'E', 0x09 }, { 'F', 0x07 },
+        { 'G', 0x0F }, { 'H', 0x0D }, { 'I', 0x06 }, { 'J', 0x0E }, { 'K', 0x11 }, { 'L', 0x15 },
+        { 'M', 0x13 }, { 'N', 0x1B }, { 'O', 0x19 }, { 'P', 0x17 }, { 'Q', 0x1F }, { 'R', 0x1D },
+        { 'S', 0x16 }, { 'T', 0x1E }, { 'U', 0x31 }, { 'V', 0x35 }, { 'W', 0x2E }, { 'X', 0x33 },
+        { 'Y', 0x3B }, { 'Z', 0x39 }, { ' ', 0x00 }, { ',', 0x04 }, { '.', 0x2C }, { '$', 0xFF },
     };
 
     SkipWhitespace();
@@ -340,22 +276,17 @@ int AsmFile::ReadBraille(unsigned char* s)
 
     m_pos++;
 
-    while (m_buffer[m_pos] != '"')
-    {
+    while (m_buffer[m_pos] != '"') {
         if (length == kMaxStringLength)
             RaiseError("mapped string longer than %d bytes", kMaxStringLength);
 
-        if (m_buffer[m_pos] == '\\' && m_buffer[m_pos + 1] == 'n')
-        {
+        if (m_buffer[m_pos] == '\\' && m_buffer[m_pos + 1] == 'n') {
             s[length++] = 0xFE;
             m_pos += 2;
-        }
-        else
-        {
+        } else {
             char c = m_buffer[m_pos];
 
-            if (encoding.count(c) == 0)
-            {
+            if (encoding.count(c) == 0) {
                 if (IsAsciiPrintable(c))
                     RaiseError("character '%c' not valid in braille string", m_buffer[m_pos]);
                 else
@@ -376,10 +307,8 @@ int AsmFile::ReadBraille(unsigned char* s)
 
 // If we're at a comma, consumes it.
 // Returns whether a comma was found.
-bool AsmFile::ConsumeComma()
-{
-    if (m_buffer[m_pos] == ',')
-    {
+bool AsmFile::ConsumeComma() {
+    if (m_buffer[m_pos] == ',') {
         m_pos++;
         return true;
     }
@@ -388,8 +317,7 @@ bool AsmFile::ConsumeComma()
 }
 
 // Converts digit character to numerical value.
-static int ConvertDigit(char c, int radix)
-{
+static int ConvertDigit(char c, int radix) {
     int digit;
 
     if (c >= '0' && c <= '9')
@@ -405,15 +333,13 @@ static int ConvertDigit(char c, int radix)
 }
 
 // Reads an integer. If the integer is greater than maxValue, it returns -1.
-int AsmFile::ReadPadLength()
-{
+int AsmFile::ReadPadLength() {
     if (!IsAsciiDigit(m_buffer[m_pos]))
         RaiseError("expected integer");
 
     int radix = 10;
 
-    if (m_buffer[m_pos] == '0' && m_buffer[m_pos + 1] == 'x')
-    {
+    if (m_buffer[m_pos] == '0' && m_buffer[m_pos + 1] == 'x') {
         radix = 16;
         m_pos += 2;
     }
@@ -421,8 +347,7 @@ int AsmFile::ReadPadLength()
     unsigned n = 0;
     int digit;
 
-    while ((digit = ConvertDigit(m_buffer[m_pos], radix)) != -1)
-    {
+    while ((digit = ConvertDigit(m_buffer[m_pos], radix)) != -1) {
         n = n * radix + digit;
 
         if (n > kMaxStringLength)
@@ -435,25 +360,18 @@ int AsmFile::ReadPadLength()
 }
 
 // Outputs the current line and moves to the next one.
-void AsmFile::OutputLine()
-{
+void AsmFile::OutputLine() {
     while (m_buffer[m_pos] != '\n' && m_buffer[m_pos] != 0)
         m_pos++;
 
-    if (m_buffer[m_pos] == 0)
-    {
-        if (m_pos >= m_size)
-        {
+    if (m_buffer[m_pos] == 0) {
+        if (m_pos >= m_size) {
             RaiseWarning("file doesn't end with newline");
             puts(&m_buffer[m_lineStart]);
-        }
-        else
-        {
+        } else {
             RaiseError("unexpected null character");
         }
-    }
-    else
-    {
+    } else {
         m_buffer[m_pos] = 0;
         puts(&m_buffer[m_lineStart]);
         m_buffer[m_pos] = '\n';
@@ -464,72 +382,58 @@ void AsmFile::OutputLine()
 }
 
 // Asserts that the rest of the line is empty and moves to the next one.
-void AsmFile::ExpectEmptyRestOfLine()
-{
+void AsmFile::ExpectEmptyRestOfLine() {
     SkipWhitespace();
 
-    if (m_buffer[m_pos] == 0)
-    {
+    if (m_buffer[m_pos] == 0) {
         if (m_pos >= m_size)
             RaiseWarning("file doesn't end with newline");
         else
             RaiseError("unexpected null character");
-    }
-    else if (m_buffer[m_pos] == '\n')
-    {
+    } else if (m_buffer[m_pos] == '\n') {
         m_pos++;
         m_lineStart = m_pos;
         m_lineNum++;
-    }
-    else if (m_buffer[m_pos] == '\r')
-    {
+    } else if (m_buffer[m_pos] == '\r') {
         RaiseError("only Unix-style LF newlines are supported");
-    }
-    else
-    {
+    } else {
         RaiseError("junk at end of line");
     }
 }
 
 // Checks if we're at the end of the file.
-bool AsmFile::IsAtEnd()
-{
+bool AsmFile::IsAtEnd() {
     return (m_pos >= m_size);
 }
 
 // Output the current location to set gas's logical file and line numbers.
-void AsmFile::OutputLocation()
-{
+void AsmFile::OutputLocation() {
     std::printf("# %ld \"%s\"\n", m_lineNum, m_filename.c_str());
 }
 
 // Reports a diagnostic message.
-void AsmFile::ReportDiagnostic(const char* type, const char* format, std::va_list args)
-{
+void AsmFile::ReportDiagnostic(const char* type, const char* format, std::va_list args) {
     const int bufferSize = 1024;
     char buffer[bufferSize];
     std::vsnprintf(buffer, bufferSize, format, args);
     std::fprintf(stderr, "%s:%ld: %s: %s\n", m_filename.c_str(), m_lineNum, type, buffer);
 }
 
-#define DO_REPORT(type)                   \
-do                                        \
-{                                         \
-    std::va_list args;                    \
-    va_start(args, format);               \
-    ReportDiagnostic(type, format, args); \
-    va_end(args);                         \
-} while (0)
+#define DO_REPORT(type)                       \
+    do {                                      \
+        std::va_list args;                    \
+        va_start(args, format);               \
+        ReportDiagnostic(type, format, args); \
+        va_end(args);                         \
+    } while (0)
 
 // Reports an error diagnostic and terminates the program.
-void AsmFile::RaiseError(const char* format, ...)
-{
+void AsmFile::RaiseError(const char* format, ...) {
     DO_REPORT("error");
     std::exit(1);
 }
 
 // Reports a warning diagnostic.
-void AsmFile::RaiseWarning(const char* format, ...)
-{
+void AsmFile::RaiseWarning(const char* format, ...) {
     DO_REPORT("warning");
 }
diff --git a/tools/src/preproc/asm_file.h b/tools/src/preproc/asm_file.h
index d73b36e9..dc8838fe 100755..100644
--- a/tools/src/preproc/asm_file.h
+++ b/tools/src/preproc/asm_file.h
@@ -26,17 +26,10 @@
 #include <string>
 #include "preproc.h"
 
-enum class Directive
-{
-    Include,
-    String,
-    Braille,
-    Unknown
-};
+enum class Directive { Include, String, Braille, Unknown };
 
-class AsmFile
-{
-public:
+class AsmFile {
+  public:
     AsmFile(std::string filename);
     AsmFile(AsmFile&& other);
     AsmFile(const AsmFile&) = delete;
@@ -50,7 +43,7 @@ public:
     void OutputLine();
     void OutputLocation();
 
-private:
+  private:
     char* m_buffer;
     long m_pos;
     long m_size;
diff --git a/tools/src/preproc/c_file.cpp b/tools/src/preproc/c_file.cpp
index d9775eb6..5ef403b3 100755..100644
--- a/tools/src/preproc/c_file.cpp
+++ b/tools/src/preproc/c_file.cpp
@@ -29,9 +29,8 @@
 #include "utf8.h"
 #include "string_parser.h"
 
-CFile::CFile(std::string filename) : m_filename(filename)
-{
-    FILE *fp = std::fopen(filename.c_str(), "rb");
+CFile::CFile(std::string filename) : m_filename(filename) {
+    FILE* fp = std::fopen(filename.c_str(), "rb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open \"%s\" for reading.\n", filename.c_str());
@@ -58,8 +57,7 @@ CFile::CFile(std::string filename) : m_filename(filename)
     m_lineNum = 1;
 }
 
-CFile::CFile(CFile&& other) : m_filename(std::move(other.m_filename))
-{
+CFile::CFile(CFile&& other) : m_filename(std::move(other.m_filename)) {
     m_buffer = other.m_buffer;
     m_pos = other.m_pos;
     m_size = other.m_size;
@@ -68,41 +66,30 @@ CFile::CFile(CFile&& other) : m_filename(std::move(other.m_filename))
     other.m_buffer = nullptr;
 }
 
-CFile::~CFile()
-{
+CFile::~CFile() {
     delete[] m_buffer;
 }
 
-void CFile::Preproc()
-{
+void CFile::Preproc() {
     char stringChar = 0;
 
-    while (m_pos < m_size)
-    {
-        if (stringChar)
-        {
-            if (m_buffer[m_pos] == stringChar)
-            {
+    while (m_pos < m_size) {
+        if (stringChar) {
+            if (m_buffer[m_pos] == stringChar) {
                 std::putchar(stringChar);
                 m_pos++;
                 stringChar = 0;
-            }
-            else if (m_buffer[m_pos] == '\\' && m_buffer[m_pos + 1] == stringChar)
-            {
+            } else if (m_buffer[m_pos] == '\\' && m_buffer[m_pos + 1] == stringChar) {
                 std::putchar('\\');
                 std::putchar(stringChar);
                 m_pos += 2;
-            }
-            else
-            {
+            } else {
                 if (m_buffer[m_pos] == '\n')
                     m_lineNum++;
                 std::putchar(m_buffer[m_pos]);
                 m_pos++;
             }
-        }
-        else
-        {
+        } else {
             TryConvertString();
             TryConvertIncbin();
 
@@ -123,10 +110,8 @@ void CFile::Preproc()
     }
 }
 
-bool CFile::ConsumeHorizontalWhitespace()
-{
-    if (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' ')
-    {
+bool CFile::ConsumeHorizontalWhitespace() {
+    if (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' ') {
         m_pos++;
         return true;
     }
@@ -134,18 +119,15 @@ bool CFile::ConsumeHorizontalWhitespace()
     return false;
 }
 
-bool CFile::ConsumeNewline()
-{
-    if (m_buffer[m_pos] == '\r' && m_buffer[m_pos + 1] == '\n')
-    {
+bool CFile::ConsumeNewline() {
+    if (m_buffer[m_pos] == '\r' && m_buffer[m_pos + 1] == '\n') {
         m_pos += 2;
         m_lineNum++;
         std::putchar('\n');
         return true;
     }
 
-    if (m_buffer[m_pos] == '\n')
-    {
+    if (m_buffer[m_pos] == '\n') {
         m_pos++;
         m_lineNum++;
         std::putchar('\n');
@@ -155,14 +137,12 @@ bool CFile::ConsumeNewline()
     return false;
 }
 
-void CFile::SkipWhitespace()
-{
+void CFile::SkipWhitespace() {
     while (ConsumeHorizontalWhitespace() || ConsumeNewline())
         ;
 }
 
-void CFile::TryConvertString()
-{
+void CFile::TryConvertString() {
     long oldPos = m_pos;
     long oldLineNum = m_lineNum;
     bool noTerminator = false;
@@ -172,16 +152,14 @@ void CFile::TryConvertString()
 
     m_pos++;
 
-    if (m_buffer[m_pos] == '_')
-    {
+    if (m_buffer[m_pos] == '_') {
         noTerminator = true;
         m_pos++;
     }
 
     SkipWhitespace();
 
-    if (m_buffer[m_pos] != '(')
-    {
+    if (m_buffer[m_pos] != '(') {
         m_pos = oldPos;
         m_lineNum = oldLineNum;
         return;
@@ -193,35 +171,24 @@ void CFile::TryConvertString()
 
     std::printf("{ ");
 
-    while (1)
-    {
+    while (1) {
         SkipWhitespace();
 
-        if (m_buffer[m_pos] == '"')
-        {
+        if (m_buffer[m_pos] == '"') {
             unsigned char s[kMaxStringLength];
             int length;
             StringParser stringParser(m_buffer, m_size);
 
-            try
-            {
+            try {
                 m_pos += stringParser.ParseString(m_pos, s, length);
-            }
-            catch (std::runtime_error& e)
-            {
-                RaiseError(e.what());
-            }
+            } catch (std::runtime_error& e) { RaiseError(e.what()); }
 
             for (int i = 0; i < length; i++)
                 printf("0x%02X, ", s[i]);
-        }
-        else if (m_buffer[m_pos] == ')')
-        {
+        } else if (m_buffer[m_pos] == ')') {
             m_pos++;
             break;
-        }
-        else
-        {
+        } else {
             if (m_pos >= m_size)
                 RaiseError("unexpected EOF");
             if (IsAsciiPrintable(m_buffer[m_pos]))
@@ -237,8 +204,7 @@ void CFile::TryConvertString()
         std::printf("0xFF }");
 }
 
-bool CFile::CheckIdentifier(const std::string& ident)
-{
+bool CFile::CheckIdentifier(const std::string& ident) {
     unsigned int i;
 
     for (i = 0; i < ident.length() && m_pos + i < (unsigned)m_size; i++)
@@ -248,8 +214,7 @@ bool CFile::CheckIdentifier(const std::string& ident)
     return (i == ident.length());
 }
 
-std::unique_ptr<unsigned char[]> CFile::ReadWholeFile(const std::string& path, int& size)
-{
+std::unique_ptr<unsigned char[]> CFile::ReadWholeFile(const std::string& path, int& size) {
     FILE* fp = std::fopen(path.c_str(), "rb");
 
     if (fp == nullptr)
@@ -271,34 +236,25 @@ std::unique_ptr<unsigned char[]> CFile::ReadWholeFile(const std::string& path, i
     return buffer;
 }
 
-int ExtractData(const std::unique_ptr<unsigned char[]>& buffer, int offset, int size)
-{
-    switch (size)
-    {
-    case 1:
-        return buffer[offset];
-    case 2:
-        return (buffer[offset + 1] << 8)
-            | buffer[offset];
-    case 4:
-        return (buffer[offset + 3] << 24)
-            | (buffer[offset + 2] << 16)
-            | (buffer[offset + 1] << 8)
-            | buffer[offset];
-    default:
-        FATAL_ERROR("Invalid size passed to ExtractData.\n");
+int ExtractData(const std::unique_ptr<unsigned char[]>& buffer, int offset, int size) {
+    switch (size) {
+        case 1:
+            return buffer[offset];
+        case 2:
+            return (buffer[offset + 1] << 8) | buffer[offset];
+        case 4:
+            return (buffer[offset + 3] << 24) | (buffer[offset + 2] << 16) | (buffer[offset + 1] << 8) | buffer[offset];
+        default:
+            FATAL_ERROR("Invalid size passed to ExtractData.\n");
     }
 }
 
-void CFile::TryConvertIncbin()
-{
+void CFile::TryConvertIncbin() {
     std::string idents[6] = { "INCBIN_S8", "INCBIN_U8", "INCBIN_S16", "INCBIN_U16", "INCBIN_S32", "INCBIN_U32" };
     int incbinType = -1;
 
-    for (int i = 0; i < 6; i++)
-    {
-        if (CheckIdentifier(idents[i]))
-        {
+    for (int i = 0; i < 6; i++) {
+        if (CheckIdentifier(idents[i])) {
             incbinType = i;
             break;
         }
@@ -317,8 +273,7 @@ void CFile::TryConvertIncbin()
 
     SkipWhitespace();
 
-    if (m_buffer[m_pos] != '(')
-    {
+    if (m_buffer[m_pos] != '(') {
         m_pos = oldPos;
         m_lineNum = oldLineNum;
         return;
@@ -328,8 +283,7 @@ void CFile::TryConvertIncbin()
 
     std::printf("{");
 
-    while (true)
-    {
+    while (true) {
         SkipWhitespace();
 
         if (m_buffer[m_pos] != '"')
@@ -339,10 +293,8 @@ void CFile::TryConvertIncbin()
 
         int startPos = m_pos;
 
-        while (m_buffer[m_pos] != '"')
-        {
-            if (m_buffer[m_pos] == 0)
-            {
+        while (m_buffer[m_pos] != '"') {
+            if (m_buffer[m_pos] == 0) {
                 if (m_pos >= m_size)
                     RaiseError("unexpected EOF in path string");
                 else
@@ -354,7 +306,7 @@ void CFile::TryConvertIncbin()
 
             if (m_buffer[m_pos] == '\\')
                 RaiseError("unexpected escape in path string");
-            
+
             m_pos++;
         }
 
@@ -371,8 +323,7 @@ void CFile::TryConvertIncbin()
         int count = fileSize / size;
         int offset = 0;
 
-        for (int i = 0; i < count; i++)
-        {
+        for (int i = 0; i < count; i++) {
             int data = ExtractData(buffer, offset, size);
             offset += size;
 
@@ -389,7 +340,7 @@ void CFile::TryConvertIncbin()
 
         m_pos++;
     }
-    
+
     if (m_buffer[m_pos] != ')')
         RaiseError("expected ')'");
 
@@ -399,32 +350,28 @@ void CFile::TryConvertIncbin()
 }
 
 // Reports a diagnostic message.
-void CFile::ReportDiagnostic(const char* type, const char* format, std::va_list args)
-{
+void CFile::ReportDiagnostic(const char* type, const char* format, std::va_list args) {
     const int bufferSize = 1024;
     char buffer[bufferSize];
     std::vsnprintf(buffer, bufferSize, format, args);
     std::fprintf(stderr, "%s:%ld: %s: %s\n", m_filename.c_str(), m_lineNum, type, buffer);
 }
 
-#define DO_REPORT(type)                   \
-do                                        \
-{                                         \
-    std::va_list args;                    \
-    va_start(args, format);               \
-    ReportDiagnostic(type, format, args); \
-    va_end(args);                         \
-} while (0)
+#define DO_REPORT(type)                       \
+    do {                                      \
+        std::va_list args;                    \
+        va_start(args, format);               \
+        ReportDiagnostic(type, format, args); \
+        va_end(args);                         \
+    } while (0)
 
 // Reports an error diagnostic and terminates the program.
-void CFile::RaiseError(const char* format, ...)
-{
+void CFile::RaiseError(const char* format, ...) {
     DO_REPORT("error");
     std::exit(1);
 }
 
 // Reports a warning diagnostic.
-void CFile::RaiseWarning(const char* format, ...)
-{
+void CFile::RaiseWarning(const char* format, ...) {
     DO_REPORT("warning");
 }
diff --git a/tools/src/preproc/c_file.h b/tools/src/preproc/c_file.h
index 7369aba8..2d565179 100755..100644
--- a/tools/src/preproc/c_file.h
+++ b/tools/src/preproc/c_file.h
@@ -27,16 +27,15 @@
 #include <memory>
 #include "preproc.h"
 
-class CFile
-{
-public:
+class CFile {
+  public:
     CFile(std::string filename);
     CFile(CFile&& other);
     CFile(const CFile&) = delete;
     ~CFile();
     void Preproc();
 
-private:
+  private:
     char* m_buffer;
     long m_pos;
     long m_size;
diff --git a/tools/src/preproc/char_util.h b/tools/src/preproc/char_util.h
index 02a6e1ce..23b7db79 100755..100644
--- a/tools/src/preproc/char_util.h
+++ b/tools/src/preproc/char_util.h
@@ -24,47 +24,37 @@
 #include <cstdint>
 #include <cassert>
 
-inline bool IsAscii(unsigned char c)
-{
+inline bool IsAscii(unsigned char c) {
     return (c < 128);
 }
 
-inline bool IsAsciiAlpha(unsigned char c)
-{
+inline bool IsAsciiAlpha(unsigned char c) {
     return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
 }
 
-inline bool IsAsciiDigit(unsigned char c)
-{
+inline bool IsAsciiDigit(unsigned char c) {
     return (c >= '0' && c <= '9');
 }
 
-inline bool IsAsciiHexDigit(unsigned char c)
-{
-    return ((c >= '0' && c <= '9')
-        || (c >= 'a' && c <= 'f')
-        || (c >= 'A' && c <= 'F'));
+inline bool IsAsciiHexDigit(unsigned char c) {
+    return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
 }
 
-inline bool IsAsciiAlphanum(unsigned char c)
-{
+inline bool IsAsciiAlphanum(unsigned char c) {
     return (IsAsciiAlpha(c) || IsAsciiDigit(c));
 }
 
-inline bool IsAsciiPrintable(unsigned char c)
-{
+inline bool IsAsciiPrintable(unsigned char c) {
     return (c >= ' ' && c <= '~');
 }
 
 // Returns whether the character can start a C identifier or the identifier of a "{FOO}" constant in strings.
-inline bool IsIdentifierStartingChar(unsigned char c)
-{
+inline bool IsIdentifierStartingChar(unsigned char c) {
     return IsAsciiAlpha(c) || c == '_';
 }
 
 // Returns whether the character can be used in a C identifier or the identifier of a "{FOO}" constant in strings.
-inline bool IsIdentifierChar(unsigned char c)
-{
+inline bool IsIdentifierChar(unsigned char c) {
     return IsAsciiAlphanum(c) || c == '_';
 }
 
diff --git a/tools/src/preproc/charmap.cpp b/tools/src/preproc/charmap.cpp
index 45a6b50a..d86eb755 100755..100644
--- a/tools/src/preproc/charmap.cpp
+++ b/tools/src/preproc/charmap.cpp
@@ -26,24 +26,16 @@
 #include "char_util.h"
 #include "utf8.h"
 
-enum LhsType
-{
-    Char,
-    Escape,
-    Constant,
-    None
-};
+enum LhsType { Char, Escape, Constant, None };
 
-struct Lhs
-{
+struct Lhs {
     LhsType type;
     std::string name;
     std::int32_t code;
 };
 
-class CharmapReader
-{
-public:
+class CharmapReader {
+  public:
     CharmapReader(std::string filename);
     CharmapReader(const CharmapReader&) = delete;
     ~CharmapReader();
@@ -53,7 +45,7 @@ public:
     void ExpectEmptyRestOfLine();
     void RaiseError(const char* format, ...);
 
-private:
+  private:
     char* m_buffer;
     long m_pos;
     long m_size;
@@ -65,17 +57,15 @@ private:
     void SkipWhitespace();
 };
 
-CharmapReader::CharmapReader(std::string filename) : m_filename(filename)
-{
-    if (filename == "")
-    {
+CharmapReader::CharmapReader(std::string filename) : m_filename(filename) {
+    if (filename == "") {
         m_pos = 0;
         m_size = 0;
-        m_buffer = new char[1] {};
+        m_buffer = new char[1]{};
         return;
     }
 
-    FILE *fp = std::fopen(filename.c_str(), "rb");
+    FILE* fp = std::fopen(filename.c_str(), "rb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open \"%s\" for reading.\n", filename.c_str());
@@ -104,45 +94,36 @@ CharmapReader::CharmapReader(std::string filename) : m_filename(filename)
     RemoveComments();
 }
 
-CharmapReader::~CharmapReader()
-{
+CharmapReader::~CharmapReader() {
     delete[] m_buffer;
 }
 
-Lhs CharmapReader::ReadLhs()
-{
+Lhs CharmapReader::ReadLhs() {
     Lhs lhs;
 
-    for (;;)
-    {
+    for (;;) {
         SkipWhitespace();
 
-        if (m_buffer[m_pos] == '\n')
-        {
+        if (m_buffer[m_pos] == '\n') {
             m_pos++;
             m_lineNum++;
-        }
-        else
-        {
+        } else {
             break;
         }
     }
-    
-    if (m_buffer[m_pos] == '\'')
-    {
+
+    if (m_buffer[m_pos] == '\'') {
         m_pos++;
 
         bool isEscape = (m_buffer[m_pos] == '\\');
 
-        if (isEscape)
-        {
+        if (isEscape) {
             m_pos++;
         }
 
         unsigned char c = m_buffer[m_pos];
 
-        if (c == 0)
-        {
+        if (c == 0) {
             if (m_pos >= m_size)
                 RaiseError("unexpected EOF in UTF-8 character literal");
             else
@@ -167,58 +148,45 @@ Lhs CharmapReader::ReadLhs()
 
         lhs.code = code;
 
-        if (isEscape)
-        {
+        if (isEscape) {
             if (code >= 128)
                 RaiseError("escapes using non-ASCII characters are invalid");
 
-            switch (code)
-            {
-            case '\'':
-                lhs.type = LhsType::Char;
-                break;
-            case '\\':
-                lhs.type = LhsType::Char;
-            case '"':
-                RaiseError("cannot escape double quote");
-                break;
-            default:
-                lhs.type = LhsType::Escape;
+            switch (code) {
+                case '\'':
+                    lhs.type = LhsType::Char;
+                    break;
+                case '\\':
+                    lhs.type = LhsType::Char;
+                case '"':
+                    RaiseError("cannot escape double quote");
+                    break;
+                default:
+                    lhs.type = LhsType::Escape;
             }
-        }
-        else
-        {
+        } else {
             if (code == '\'')
                 RaiseError("empty character literal");
 
             lhs.type = LhsType::Char;
         }
-    }
-    else if (IsIdentifierStartingChar(m_buffer[m_pos]))
-    {
+    } else if (IsIdentifierStartingChar(m_buffer[m_pos])) {
         lhs.type = LhsType::Constant;
         lhs.name = ReadConstant();
-    }
-    else if (m_buffer[m_pos] == '\r')
-    {
+    } else if (m_buffer[m_pos] == '\r') {
         RaiseError("only Unix-style LF newlines are supported");
-    }
-    else if (m_buffer[m_pos] == 0)
-    {
+    } else if (m_buffer[m_pos] == 0) {
         if (m_pos < m_size)
             RaiseError("unexpected null character");
         lhs.type = LhsType::None;
-    }
-    else
-    {
+    } else {
         RaiseError("junk at start of line");
     }
 
     return lhs;
 }
 
-void CharmapReader::ExpectEqualsSign()
-{
+void CharmapReader::ExpectEqualsSign() {
     SkipWhitespace();
 
     if (m_buffer[m_pos] != '=')
@@ -227,8 +195,7 @@ void CharmapReader::ExpectEqualsSign()
     m_pos++;
 }
 
-static unsigned int ConvertHexDigit(char c)
-{
+static unsigned int ConvertHexDigit(char c) {
     unsigned int digit = 0;
 
     if (c >= '0' && c <= '9')
@@ -241,16 +208,14 @@ static unsigned int ConvertHexDigit(char c)
     return digit;
 }
 
-std::string CharmapReader::ReadSequence()
-{
+std::string CharmapReader::ReadSequence() {
     SkipWhitespace();
 
     long startPos = m_pos;
 
     unsigned int length = 0;
 
-    while (IsAsciiHexDigit(m_buffer[m_pos]) && IsAsciiHexDigit(m_buffer[m_pos + 1]))
-    {
+    while (IsAsciiHexDigit(m_buffer[m_pos]) && IsAsciiHexDigit(m_buffer[m_pos + 1])) {
         m_pos += 2;
         length++;
 
@@ -271,8 +236,7 @@ std::string CharmapReader::ReadSequence()
 
     m_pos = startPos;
 
-    for (unsigned int i = 0; i < length; i++)
-    {
+    for (unsigned int i = 0; i < length; i++) {
         unsigned int digit1 = ConvertHexDigit(m_buffer[m_pos]);
         unsigned int digit2 = ConvertHexDigit(m_buffer[m_pos + 1]);
         unsigned char byte = digit1 * 16 + digit2;
@@ -285,32 +249,23 @@ std::string CharmapReader::ReadSequence()
     return sequence;
 }
 
-void CharmapReader::ExpectEmptyRestOfLine()
-{
+void CharmapReader::ExpectEmptyRestOfLine() {
     SkipWhitespace();
 
-    if (m_buffer[m_pos] == 0)
-    {
+    if (m_buffer[m_pos] == 0) {
         if (m_pos < m_size)
             RaiseError("unexpected null character");
-    }
-    else if (m_buffer[m_pos] == '\n')
-    {
+    } else if (m_buffer[m_pos] == '\n') {
         m_pos++;
         m_lineNum++;
-    }
-    else if (m_buffer[m_pos] == '\r')
-    {
+    } else if (m_buffer[m_pos] == '\r') {
         RaiseError("only Unix-style LF newlines are supported");
-    }
-    else
-    {
+    } else {
         RaiseError("junk at end of line");
     }
 }
 
-void CharmapReader::RaiseError(const char* format, ...)
-{
+void CharmapReader::RaiseError(const char* format, ...) {
     const int bufferSize = 1024;
     char buffer[bufferSize];
 
@@ -324,36 +279,26 @@ void CharmapReader::RaiseError(const char* format, ...)
     std::exit(1);
 }
 
-void CharmapReader::RemoveComments()
-{
+void CharmapReader::RemoveComments() {
     long pos = 0;
     bool inString = false;
 
-    for (;;)
-    {
+    for (;;) {
         if (m_buffer[pos] == 0)
             return;
 
-        if (inString)
-        {
-            if (m_buffer[pos] == '\\' && m_buffer[pos + 1] == '\'')
-            {
+        if (inString) {
+            if (m_buffer[pos] == '\\' && m_buffer[pos + 1] == '\'') {
                 pos += 2;
-            }
-            else
-            {
+            } else {
                 if (m_buffer[pos] == '\'')
                     inString = false;
                 pos++;
             }
-        }
-        else if (m_buffer[pos] == '@')
-        {
+        } else if (m_buffer[pos] == '@') {
             while (m_buffer[pos] != '\n' && m_buffer[pos] != 0)
                 m_buffer[pos++] = ' ';
-        }
-        else
-        {
+        } else {
             if (m_buffer[pos] == '\'')
                 inString = true;
             pos++;
@@ -361,8 +306,7 @@ void CharmapReader::RemoveComments()
     }
 }
 
-std::string CharmapReader::ReadConstant()
-{
+std::string CharmapReader::ReadConstant() {
     long startPos = m_pos;
 
     while (IsIdentifierChar(m_buffer[m_pos]))
@@ -371,18 +315,15 @@ std::string CharmapReader::ReadConstant()
     return std::string(&m_buffer[startPos], m_pos - startPos);
 }
 
-void CharmapReader::SkipWhitespace()
-{
+void CharmapReader::SkipWhitespace() {
     while (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' ')
         m_pos++;
 }
 
-Charmap::Charmap(std::string filename)
-{
+Charmap::Charmap(std::string filename) {
     CharmapReader reader(filename);
 
-    for (;;)
-    {
+    for (;;) {
         Lhs lhs = reader.ReadLhs();
 
         if (lhs.type == LhsType::None)
@@ -392,23 +333,22 @@ Charmap::Charmap(std::string filename)
 
         std::string sequence = reader.ReadSequence();
 
-        switch (lhs.type)
-        {
-        case LhsType::Char:
-            if (m_chars.find(lhs.code) != m_chars.end())
-                reader.RaiseError("redefining char");
-            m_chars[lhs.code] = sequence;
-            break;
-        case LhsType::Escape:
-            if (m_escapes[lhs.code].length() != 0)
-                reader.RaiseError("redefining escape");
-            m_escapes[lhs.code] = sequence;
-            break;
-        case LhsType::Constant:
-            if (m_constants.find(lhs.name) != m_constants.end())
-                reader.RaiseError("redefining constant");
-            m_constants[lhs.name] = sequence;
-            break;
+        switch (lhs.type) {
+            case LhsType::Char:
+                if (m_chars.find(lhs.code) != m_chars.end())
+                    reader.RaiseError("redefining char");
+                m_chars[lhs.code] = sequence;
+                break;
+            case LhsType::Escape:
+                if (m_escapes[lhs.code].length() != 0)
+                    reader.RaiseError("redefining escape");
+                m_escapes[lhs.code] = sequence;
+                break;
+            case LhsType::Constant:
+                if (m_constants.find(lhs.name) != m_constants.end())
+                    reader.RaiseError("redefining constant");
+                m_constants[lhs.name] = sequence;
+                break;
         }
 
         reader.ExpectEmptyRestOfLine();
diff --git a/tools/src/preproc/charmap.h b/tools/src/preproc/charmap.h
index 0d752ac9..f4eaca84 100755..100644
--- a/tools/src/preproc/charmap.h
+++ b/tools/src/preproc/charmap.h
@@ -26,13 +26,11 @@
 #include <map>
 #include <vector>
 
-class Charmap
-{
-public:
+class Charmap {
+  public:
     Charmap(std::string filename);
 
-    std::string Char(std::int32_t code)
-    {
+    std::string Char(std::int32_t code) {
         auto it = m_chars.find(code);
 
         if (it == m_chars.end())
@@ -41,13 +39,11 @@ public:
         return it->second;
     }
 
-    std::string Escape(unsigned char code)
-    {
+    std::string Escape(unsigned char code) {
         return m_escapes[code];
     }
 
-    std::string Constant(std::string identifier)
-    {
+    std::string Constant(std::string identifier) {
         auto it = m_constants.find(identifier);
 
         if (it == m_constants.end())
@@ -55,7 +51,8 @@ public:
 
         return it->second;
     }
-private:
+
+  private:
     std::map<std::int32_t, std::string> m_chars;
     std::string m_escapes[128];
     std::map<std::string, std::string> m_constants;
diff --git a/tools/src/preproc/preproc.cpp b/tools/src/preproc/preproc.cpp
index 3fd3ae6b..2aada83d 100755..100644
--- a/tools/src/preproc/preproc.cpp
+++ b/tools/src/preproc/preproc.cpp
@@ -28,13 +28,10 @@
 Charmap* g_charmap;
 std::string g_buildName;
 
-void PrintAsmBytes(unsigned char *s, int length)
-{
-    if (length > 0)
-    {
+void PrintAsmBytes(unsigned char* s, int length) {
+    if (length > 0) {
         std::printf("\t.byte ");
-        for (int i = 0; i < length; i++)
-        {
+        for (int i = 0; i < length; i++) {
             std::printf("0x%02X", s[i]);
 
             if (i < length - 1)
@@ -44,16 +41,13 @@ void PrintAsmBytes(unsigned char *s, int length)
     }
 }
 
-void PreprocAsmFile(std::string filename)
-{
+void PreprocAsmFile(std::string filename) {
     std::stack<AsmFile> stack;
 
     stack.push(AsmFile(filename));
 
-    for (;;)
-    {
-        while (stack.top().IsAtEnd())
-        {
+    for (;;) {
+        while (stack.top().IsAtEnd()) {
             stack.pop();
 
             if (stack.empty())
@@ -64,54 +58,45 @@ void PreprocAsmFile(std::string filename)
 
         Directive directive = stack.top().GetDirective();
 
-        switch (directive)
-        {
-        case Directive::Include:
-            stack.push(AsmFile(stack.top().ReadPath()));
-            stack.top().OutputLocation();
-            break;
-        case Directive::String:
-        {
-            unsigned char s[kMaxStringLength];
-            int length = stack.top().ReadString(s);
-            PrintAsmBytes(s, length);
-            break;
-        }
-        case Directive::Braille:
-        {
-            unsigned char s[kMaxStringLength];
-            int length = stack.top().ReadBraille(s);
-            PrintAsmBytes(s, length);
-            break;
-        }
-        case Directive::Unknown:
-        {
-            std::string globalLabel = stack.top().GetGlobalLabel();
-
-            if (globalLabel.length() != 0)
-            {
-                const char *s = globalLabel.c_str();
-                std::printf("%s: ; .global %s\n", s, s);
+        switch (directive) {
+            case Directive::Include:
+                stack.push(AsmFile(stack.top().ReadPath()));
+                stack.top().OutputLocation();
+                break;
+            case Directive::String: {
+                unsigned char s[kMaxStringLength];
+                int length = stack.top().ReadString(s);
+                PrintAsmBytes(s, length);
+                break;
             }
-            else
-            {
-                stack.top().OutputLine();
+            case Directive::Braille: {
+                unsigned char s[kMaxStringLength];
+                int length = stack.top().ReadBraille(s);
+                PrintAsmBytes(s, length);
+                break;
             }
+            case Directive::Unknown: {
+                std::string globalLabel = stack.top().GetGlobalLabel();
 
-            break;
-        }
+                if (globalLabel.length() != 0) {
+                    const char* s = globalLabel.c_str();
+                    std::printf("%s: ; .global %s\n", s, s);
+                } else {
+                    stack.top().OutputLine();
+                }
+
+                break;
+            }
         }
     }
 }
 
-void PreprocCFile(std::string filename)
-{
+void PreprocCFile(std::string filename) {
     CFile cFile(filename);
     cFile.Preproc();
 }
 
-char* GetFileExtension(char* filename)
-{
+char* GetFileExtension(char* filename) {
     char* extension = filename;
 
     while (*extension != 0)
@@ -131,10 +116,8 @@ char* GetFileExtension(char* filename)
     return extension;
 }
 
-int main(int argc, char **argv)
-{
-    if (argc != 4 && argc != 3)
-    {
+int main(int argc, char** argv) {
+    if (argc != 4 && argc != 3) {
         std::fprintf(stderr, "Usage: %s BUILD_NAME SRC_FILE CHARMAP_FILE", argv[0]);
         return 1;
     }
diff --git a/tools/src/preproc/preproc.h b/tools/src/preproc/preproc.h
index 1b1e1bdf..f896b6ae 100755..100644
--- a/tools/src/preproc/preproc.h
+++ b/tools/src/preproc/preproc.h
@@ -27,21 +27,19 @@
 
 #ifdef _MSC_VER
 
-#define FATAL_ERROR(format, ...)               \
-do                                             \
-{                                              \
-    std::fprintf(stderr, format, __VA_ARGS__); \
-    std::exit(1);                              \
-} while (0)
+#define FATAL_ERROR(format, ...)                   \
+    do {                                           \
+        std::fprintf(stderr, format, __VA_ARGS__); \
+        std::exit(1);                              \
+    } while (0)
 
 #else
 
-#define FATAL_ERROR(format, ...)                 \
-do                                               \
-{                                                \
-    std::fprintf(stderr, format, ##__VA_ARGS__); \
-    std::exit(1);                                \
-} while (0)
+#define FATAL_ERROR(format, ...)                     \
+    do {                                             \
+        std::fprintf(stderr, format, ##__VA_ARGS__); \
+        std::exit(1);                                \
+    } while (0)
 
 #endif // _MSC_VER
 
diff --git a/tools/src/preproc/string_parser.cpp b/tools/src/preproc/string_parser.cpp
index dd5196a4..7c3cc1c7 100755..100644
--- a/tools/src/preproc/string_parser.cpp
+++ b/tools/src/preproc/string_parser.cpp
@@ -27,27 +27,22 @@
 #include "utf8.h"
 
 // Reads a charmap char or escape sequence.
-std::string StringParser::ReadCharOrEscape()
-{
+std::string StringParser::ReadCharOrEscape() {
     std::string sequence;
 
     bool isEscape = (m_buffer[m_pos] == '\\');
 
-    if (isEscape)
-    {
+    if (isEscape) {
         m_pos++;
 
-        if (m_buffer[m_pos] == '"')
-        {
+        if (m_buffer[m_pos] == '"') {
             sequence = g_charmap->Char('"');
 
             if (sequence.length() == 0)
                 RaiseError("no mapping exists for double quote");
 
             return sequence;
-        }
-        else if (m_buffer[m_pos] == '\\')
-        {
+        } else if (m_buffer[m_pos] == '\\') {
             sequence = g_charmap->Char('\\');
 
             if (sequence.length() == 0)
@@ -59,8 +54,7 @@ std::string StringParser::ReadCharOrEscape()
 
     unsigned char c = m_buffer[m_pos];
 
-    if (c == 0)
-    {
+    if (c == 0) {
         if (m_pos >= m_size)
             RaiseError("unexpected EOF in UTF-8 string");
         else
@@ -82,8 +76,7 @@ std::string StringParser::ReadCharOrEscape()
 
     sequence = isEscape ? g_charmap->Escape(code) : g_charmap->Char(code);
 
-    if (sequence.length() == 0)
-    {
+    if (sequence.length() == 0) {
         if (isEscape)
             RaiseError("unknown escape '\\%c'", code);
         else
@@ -94,18 +87,15 @@ std::string StringParser::ReadCharOrEscape()
 }
 
 // Reads a charmap constant, i.e. "{FOO}".
-std::string StringParser::ReadBracketedConstants()
-{
+std::string StringParser::ReadBracketedConstants() {
     std::string totalSequence;
 
     m_pos++; // Assume we're on the left curly bracket.
 
-    while (m_buffer[m_pos] != '}')
-    {
+    while (m_buffer[m_pos] != '}') {
         SkipWhitespace();
 
-        if (IsIdentifierStartingChar(m_buffer[m_pos]))
-        {
+        if (IsIdentifierStartingChar(m_buffer[m_pos])) {
             long startPos = m_pos;
 
             m_pos++;
@@ -115,44 +105,36 @@ std::string StringParser::ReadBracketedConstants()
 
             std::string sequence = g_charmap->Constant(std::string(&m_buffer[startPos], m_pos - startPos));
 
-            if (sequence.length() == 0)
-            {
+            if (sequence.length() == 0) {
                 m_buffer[m_pos] = 0;
                 RaiseError("unknown constant '%s'", &m_buffer[startPos]);
             }
 
             totalSequence += sequence;
-        }
-        else if (IsAsciiDigit(m_buffer[m_pos]))
-        {
+        } else if (IsAsciiDigit(m_buffer[m_pos])) {
             Integer integer = ReadInteger();
 
-            switch (integer.size)
-            {
-            case 1:
-                totalSequence += (unsigned char)integer.value;
-                break;
-            case 2:
-                totalSequence += (unsigned char)integer.value;
-                totalSequence += (unsigned char)(integer.value >> 8);
-                break;
-            case 4:
-                totalSequence += (unsigned char)integer.value;
-                totalSequence += (unsigned char)(integer.value >> 8);
-                totalSequence += (unsigned char)(integer.value >> 16);
-                totalSequence += (unsigned char)(integer.value >> 24);
-                break;
+            switch (integer.size) {
+                case 1:
+                    totalSequence += (unsigned char)integer.value;
+                    break;
+                case 2:
+                    totalSequence += (unsigned char)integer.value;
+                    totalSequence += (unsigned char)(integer.value >> 8);
+                    break;
+                case 4:
+                    totalSequence += (unsigned char)integer.value;
+                    totalSequence += (unsigned char)(integer.value >> 8);
+                    totalSequence += (unsigned char)(integer.value >> 16);
+                    totalSequence += (unsigned char)(integer.value >> 24);
+                    break;
             }
-        }
-        else if (m_buffer[m_pos] == 0)
-        {
+        } else if (m_buffer[m_pos] == 0) {
             if (m_pos >= m_size)
                 RaiseError("unexpected EOF after left curly bracket");
             else
                 RaiseError("unexpected null character within curly brackets");
-        }
-        else
-        {
+        } else {
             if (IsAsciiPrintable(m_buffer[m_pos]))
                 RaiseError("unexpected character '%c' within curly brackets", m_buffer[m_pos]);
             else
@@ -166,8 +148,7 @@ std::string StringParser::ReadBracketedConstants()
 }
 
 // Reads a charmap string.
-int StringParser::ParseString(long srcPos, unsigned char* dest, int& destLength)
-{
+int StringParser::ParseString(long srcPos, unsigned char* dest, int& destLength) {
     m_pos = srcPos;
 
     if (m_buffer[m_pos] != '"')
@@ -179,12 +160,10 @@ int StringParser::ParseString(long srcPos, unsigned char* dest, int& destLength)
 
     destLength = 0;
 
-    while (m_buffer[m_pos] != '"')
-    {
+    while (m_buffer[m_pos] != '"') {
         std::string sequence = (m_buffer[m_pos] == '{') ? ReadBracketedConstants() : ReadCharOrEscape();
 
-        for (const char& c : sequence)
-        {
+        for (const char& c : sequence) {
             if (destLength == kMaxStringLength)
                 RaiseError("mapped string longer than %d bytes", kMaxStringLength);
 
@@ -197,8 +176,7 @@ int StringParser::ParseString(long srcPos, unsigned char* dest, int& destLength)
     return m_pos - start;
 }
 
-void StringParser::RaiseError(const char* format, ...)
-{
+void StringParser::RaiseError(const char* format, ...) {
     const int bufferSize = 1024;
     char buffer[bufferSize];
 
@@ -211,8 +189,7 @@ void StringParser::RaiseError(const char* format, ...)
 }
 
 // Converts digit character to numerical value.
-static int ConvertDigit(char c, int radix)
-{
+static int ConvertDigit(char c, int radix) {
     int digit;
 
     if (c >= '0' && c <= '9')
@@ -227,26 +204,22 @@ static int ConvertDigit(char c, int radix)
     return (digit < radix) ? digit : -1;
 }
 
-void StringParser::SkipRestOfInteger(int radix)
-{
+void StringParser::SkipRestOfInteger(int radix) {
     while (ConvertDigit(m_buffer[m_pos], radix) != -1)
         m_pos++;
 }
 
-StringParser::Integer StringParser::ReadDecimal()
-{
+StringParser::Integer StringParser::ReadDecimal() {
     const int radix = 10;
     std::uint64_t n = 0;
     int digit;
     std::uint64_t max = UINT32_MAX;
     long startPos = m_pos;
 
-    while ((digit = ConvertDigit(m_buffer[m_pos], radix)) != -1)
-    {
+    while ((digit = ConvertDigit(m_buffer[m_pos], radix)) != -1) {
         n = n * radix + digit;
 
-        if (n >= max)
-        {
+        if (n >= max) {
             SkipRestOfInteger(radix);
 
             std::string intLiteral(m_buffer + startPos, m_pos - startPos);
@@ -258,23 +231,17 @@ StringParser::Integer StringParser::ReadDecimal()
 
     int size;
 
-    if (m_buffer[m_pos] == 'H')
-    {
-        if (n >= 0x10000)
-        {
+    if (m_buffer[m_pos] == 'H') {
+        if (n >= 0x10000) {
             RaiseError("%lu is too large to be a halfword", (unsigned long)n);
         }
 
         size = 2;
         m_pos++;
-    }
-    else if (m_buffer[m_pos] == 'W')
-    {
+    } else if (m_buffer[m_pos] == 'W') {
         size = 4;
         m_pos++;
-    }
-    else
-    {
+    } else {
         if (n >= 0x10000)
             size = 4;
         else if (n >= 0x100)
@@ -283,23 +250,20 @@ StringParser::Integer StringParser::ReadDecimal()
             size = 1;
     }
 
-    return{ static_cast<std::uint32_t>(n), size };
+    return { static_cast<std::uint32_t>(n), size };
 }
 
-StringParser::Integer StringParser::ReadHex()
-{
+StringParser::Integer StringParser::ReadHex() {
     const int radix = 16;
     std::uint64_t n = 0;
     int digit;
     std::uint64_t max = UINT32_MAX;
     long startPos = m_pos;
 
-    while ((digit = ConvertDigit(m_buffer[m_pos], radix)) != -1)
-    {
+    while ((digit = ConvertDigit(m_buffer[m_pos], radix)) != -1) {
         n = n * radix + digit;
 
-        if (n >= max)
-        {
+        if (n >= max) {
             SkipRestOfInteger(radix);
 
             std::string intLiteral(m_buffer + startPos, m_pos - startPos);
@@ -312,34 +276,30 @@ StringParser::Integer StringParser::ReadHex()
     int length = m_pos - startPos;
     int size = 0;
 
-    switch (length)
-    {
-    case 2:
-        size = 1;
-        break;
-    case 4:
-        size = 2;
-        break;
-    case 8:
-        size = 4;
-        break;
-    default:
-    {
-        std::string intLiteral(m_buffer + startPos, m_pos - startPos);
-        RaiseError("hex integer literal \"0x%s\" doesn't have length of 2, 4, or 8 digits", intLiteral.c_str());
-    }
+    switch (length) {
+        case 2:
+            size = 1;
+            break;
+        case 4:
+            size = 2;
+            break;
+        case 8:
+            size = 4;
+            break;
+        default: {
+            std::string intLiteral(m_buffer + startPos, m_pos - startPos);
+            RaiseError("hex integer literal \"0x%s\" doesn't have length of 2, 4, or 8 digits", intLiteral.c_str());
+        }
     }
 
-    return{ static_cast<std::uint32_t>(n), size };
+    return { static_cast<std::uint32_t>(n), size };
 }
 
-StringParser::Integer StringParser::ReadInteger()
-{
+StringParser::Integer StringParser::ReadInteger() {
     if (!IsAsciiDigit(m_buffer[m_pos]))
         RaiseError("expected integer");
 
-    if (m_buffer[m_pos] == '0' && m_buffer[m_pos + 1] == 'x')
-    {
+    if (m_buffer[m_pos] == '0' && m_buffer[m_pos + 1] == 'x') {
         m_pos += 2;
         return ReadHex();
     }
@@ -348,8 +308,7 @@ StringParser::Integer StringParser::ReadInteger()
 }
 
 // Skips tabs and spaces.
-void StringParser::SkipWhitespace()
-{
+void StringParser::SkipWhitespace() {
     while (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' ')
         m_pos++;
 }
diff --git a/tools/src/preproc/string_parser.h b/tools/src/preproc/string_parser.h
index abd2bfe9..2e212640 100755..100644
--- a/tools/src/preproc/string_parser.h
+++ b/tools/src/preproc/string_parser.h
@@ -25,15 +25,14 @@
 #include <string>
 #include "preproc.h"
 
-class StringParser
-{
-public:
-    StringParser(char* buffer, long size) : m_buffer(buffer), m_size(size), m_pos(0) {}
-    int ParseString(long srcPos, unsigned char* dest, int &destLength);
+class StringParser {
+  public:
+    StringParser(char* buffer, long size) : m_buffer(buffer), m_size(size), m_pos(0) {
+    }
+    int ParseString(long srcPos, unsigned char* dest, int& destLength);
 
-private:
-    struct Integer
-    {
+  private:
+    struct Integer {
         std::uint32_t value;
         int size;
     };
diff --git a/tools/src/preproc/utf8.cpp b/tools/src/preproc/utf8.cpp
index 7facfd44..abeccfe9 100755..100644
--- a/tools/src/preproc/utf8.cpp
+++ b/tools/src/preproc/utf8.cpp
@@ -24,17 +24,23 @@
 #include <cstdint>
 #include "utf8.h"
 
-static const unsigned char s_byteTypeTable[] =
-{
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
-    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
-    8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
-    0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
-    0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
+static const unsigned char s_byteTypeTable[] = {
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 00..1f
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20..3f
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 40..5f
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 60..7f
+    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
+    9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9, // 80..9f
+    7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
+    7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7, // a0..bf
+    8,   8,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
+    2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   // c0..df
+    0xa, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // e0..ef
+    0xb, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // f0..ff
 };
 
 const unsigned char s0 = 0 * 12;
@@ -47,28 +53,25 @@ const unsigned char s6 = 6 * 12;
 const unsigned char s7 = 7 * 12;
 const unsigned char s8 = 8 * 12;
 
-static const unsigned char s_transitionTable[] =
-{
-    s0,s1,s2,s3,s5,s8,s7,s1,s1,s1,s4,s6, // s0
-    s1,s1,s1,s1,s1,s1,s1,s1,s1,s1,s1,s1, // s1
-    s1,s0,s1,s1,s1,s1,s1,s0,s1,s0,s1,s1, // s2
-    s1,s2,s1,s1,s1,s1,s1,s2,s1,s2,s1,s1, // s3
-    s1,s1,s1,s1,s1,s1,s1,s2,s1,s1,s1,s1, // s4
-    s1,s2,s1,s1,s1,s1,s1,s1,s1,s2,s1,s1, // s5
-    s1,s1,s1,s1,s1,s1,s1,s3,s1,s3,s1,s1, // s6
-    s1,s3,s1,s1,s1,s1,s1,s3,s1,s3,s1,s1, // s7
-    s1,s3,s1,s1,s1,s1,s1,s1,s1,s1,s1,s1, // s8
+static const unsigned char s_transitionTable[] = {
+    s0, s1, s2, s3, s5, s8, s7, s1, s1, s1, s4, s6, // s0
+    s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // s1
+    s1, s0, s1, s1, s1, s1, s1, s0, s1, s0, s1, s1, // s2
+    s1, s2, s1, s1, s1, s1, s1, s2, s1, s2, s1, s1, // s3
+    s1, s1, s1, s1, s1, s1, s1, s2, s1, s1, s1, s1, // s4
+    s1, s2, s1, s1, s1, s1, s1, s1, s1, s2, s1, s1, // s5
+    s1, s1, s1, s1, s1, s1, s1, s3, s1, s3, s1, s1, // s6
+    s1, s3, s1, s1, s1, s1, s1, s3, s1, s3, s1, s1, // s7
+    s1, s3, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // s8
 };
 
 // Decodes UTF-8 encoded Unicode code point at "s".
-UnicodeChar DecodeUtf8(const char* s)
-{
+UnicodeChar DecodeUtf8(const char* s) {
     UnicodeChar unicodeChar;
     int state = s0;
     auto start = s;
 
-    do
-    {
+    do {
         unsigned char byte = *s++;
         int type = s_byteTypeTable[byte];
 
@@ -79,8 +82,7 @@ UnicodeChar DecodeUtf8(const char* s)
 
         state = s_transitionTable[state + type];
 
-        if (state == s1)
-        {
+        if (state == s1) {
             unicodeChar.code = -1;
             return unicodeChar;
         }
diff --git a/tools/src/preproc/utf8.h b/tools/src/preproc/utf8.h
index 259de67c..28d03d30 100755..100644
--- a/tools/src/preproc/utf8.h
+++ b/tools/src/preproc/utf8.h
@@ -23,8 +23,7 @@
 
 #include <cstdint>
 
-struct UnicodeChar
-{
+struct UnicodeChar {
     std::int32_t code;
     int encodingLength;
 };
diff --git a/tools/src/scaninc/asm_file.cpp b/tools/src/scaninc/asm_file.cpp
index 109e604a..0fa0a20d 100755..100644
--- a/tools/src/scaninc/asm_file.cpp
+++ b/tools/src/scaninc/asm_file.cpp
@@ -23,11 +23,10 @@
 #include "scaninc.h"
 #include "asm_file.h"
 
-AsmFile::AsmFile(std::string path)
-{
+AsmFile::AsmFile(std::string path) {
     m_path = path;
 
-    FILE *fp = std::fopen(path.c_str(), "rb");
+    FILE* fp = std::fopen(path.c_str(), "rb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open \"%s\" for reading.\n", path.c_str());
@@ -49,24 +48,20 @@ AsmFile::AsmFile(std::string path)
     m_lineNum = 1;
 }
 
-AsmFile::~AsmFile()
-{
+AsmFile::~AsmFile() {
     delete[] m_buffer;
 }
 
-IncDirectiveType AsmFile::ReadUntilIncDirective(std::string &path)
-{
+IncDirectiveType AsmFile::ReadUntilIncDirective(std::string& path) {
     // At the beginning of each loop iteration, the current file position
     // should be at the start of a line or at the end of the file.
-    for (;;)
-    {
+    for (;;) {
         SkipTabsAndSpaces();
 
         IncDirectiveType incDirectiveType = IncDirectiveType::None;
 
         char c = PeekChar();
-        if (c == '.' || c == '#')
-        {
+        if (c == '.' || c == '#') {
             m_pos++;
 
             if (MatchIncDirective("incbin", path))
@@ -75,29 +70,21 @@ IncDirectiveType AsmFile::ReadUntilIncDirective(std::string &path)
                 incDirectiveType = IncDirectiveType::Include;
         }
 
-        for (;;)
-        {
+        for (;;) {
             int c = GetChar();
 
             if (c == -1)
                 return incDirectiveType;
 
-            if (c == ';')
-            {
+            if (c == ';') {
                 SkipEndOfLineComment();
                 break;
-            }
-            else if (c == '/' && PeekChar() == '*')
-            {
+            } else if (c == '/' && PeekChar() == '*') {
                 m_pos++;
                 SkipMultiLineComment();
-            }
-            else if (c == '"')
-            {
+            } else if (c == '"') {
                 SkipString();
-            }
-            else if (c == '\n')
-            {
+            } else if (c == '\n') {
                 break;
             }
         }
@@ -107,13 +94,11 @@ IncDirectiveType AsmFile::ReadUntilIncDirective(std::string &path)
     }
 }
 
-std::string AsmFile::ReadPath()
-{
+std::string AsmFile::ReadPath() {
     int length = 0;
     int startPos = m_pos;
 
-    for (;;)
-    {
+    for (;;) {
         int c = GetChar();
 
         if (c == '"')
@@ -141,41 +126,31 @@ std::string AsmFile::ReadPath()
     return std::string(m_buffer + startPos, length);
 }
 
-void AsmFile::SkipEndOfLineComment()
-{
+void AsmFile::SkipEndOfLineComment() {
     int c;
 
-    do
-    {
+    do {
         c = GetChar();
     } while (c != -1 && c != '\n');
 }
 
-void AsmFile::SkipMultiLineComment()
-{
-    for (;;)
-    {
+void AsmFile::SkipMultiLineComment() {
+    for (;;) {
         int c = GetChar();
 
-        if (c == '*')
-        {
-            if (PeekChar() == '/')
-            {
+        if (c == '*') {
+            if (PeekChar() == '/') {
                 m_pos++;
                 return;
             }
-        }
-        else if (c == -1)
-        {
+        } else if (c == -1) {
             return;
         }
     }
 }
 
-void AsmFile::SkipString()
-{
-    for (;;)
-    {
+void AsmFile::SkipString() {
+    for (;;) {
         int c = GetChar();
 
         if (c == '"')
@@ -184,8 +159,7 @@ void AsmFile::SkipString()
         if (c == -1)
             FATAL_INPUT_ERROR("unexpected EOF in string\n");
 
-        if (c == '\\')
-        {
+        if (c == '\\') {
             c = GetChar();
         }
     }
diff --git a/tools/src/scaninc/asm_file.h b/tools/src/scaninc/asm_file.h
index ad99b757..1f07b169 100755..100644
--- a/tools/src/scaninc/asm_file.h
+++ b/tools/src/scaninc/asm_file.h
@@ -24,43 +24,32 @@
 #include <string>
 #include "scaninc.h"
 
-enum class IncDirectiveType
-{
-    None,
-    Include,
-    Incbin
-};
+enum class IncDirectiveType { None, Include, Incbin };
 
-class AsmFile
-{
-public:
+class AsmFile {
+  public:
     AsmFile(std::string path);
     ~AsmFile();
     IncDirectiveType ReadUntilIncDirective(std::string& path);
 
-private:
-    char *m_buffer;
+  private:
+    char* m_buffer;
     int m_pos;
     int m_size;
     int m_lineNum;
     std::string m_path;
 
-    int GetChar()
-    {
+    int GetChar() {
         if (m_pos >= m_size)
             return -1;
 
         int c = m_buffer[m_pos++];
 
-        if (c == '\r')
-        {
-            if (m_pos < m_size && m_buffer[m_pos++] == '\n')
-            {
+        if (c == '\r') {
+            if (m_pos < m_size && m_buffer[m_pos++] == '\n') {
                 m_lineNum++;
                 return '\n';
-            }
-            else
-            {
+            } else {
                 FATAL_INPUT_ERROR("CR line endings are not supported\n");
             }
         }
@@ -72,22 +61,19 @@ private:
     }
 
     // No newline translation because it's not needed for any use of this function.
-    int PeekChar()
-    {
+    int PeekChar() {
         if (m_pos >= m_size)
             return -1;
 
         return m_buffer[m_pos];
     }
 
-    void SkipTabsAndSpaces()
-    {
+    void SkipTabsAndSpaces() {
         while (m_pos < m_size && (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' '))
             m_pos++;
     }
 
-    bool MatchIncDirective(std::string directiveName, std::string& path)
-    {
+    bool MatchIncDirective(std::string directiveName, std::string& path) {
         int length = directiveName.length();
         int i;
 
diff --git a/tools/src/scaninc/c_file.cpp b/tools/src/scaninc/c_file.cpp
index 595f366c..b567d646 100755..100644
--- a/tools/src/scaninc/c_file.cpp
+++ b/tools/src/scaninc/c_file.cpp
@@ -20,11 +20,10 @@
 
 #include "c_file.h"
 
-CFile::CFile(std::string path)
-{
+CFile::CFile(std::string path) {
     m_path = path;
 
-    FILE *fp = std::fopen(path.c_str(), "rb");
+    FILE* fp = std::fopen(path.c_str(), "rb");
 
     if (fp == NULL)
         FATAL_ERROR("Failed to open \"%s\" for reading.\n", path.c_str());
@@ -47,37 +46,26 @@ CFile::CFile(std::string path)
     m_lineNum = 1;
 }
 
-CFile::~CFile()
-{
+CFile::~CFile() {
     delete[] m_buffer;
 }
 
-void CFile::FindIncbins()
-{
+void CFile::FindIncbins() {
     char stringChar = 0;
 
-    while (m_pos < m_size)
-    {
-        if (stringChar)
-        {
-            if (m_buffer[m_pos] == stringChar)
-            {
+    while (m_pos < m_size) {
+        if (stringChar) {
+            if (m_buffer[m_pos] == stringChar) {
                 m_pos++;
                 stringChar = 0;
-            }
-            else if (m_buffer[m_pos] == '\\' && m_buffer[m_pos + 1] == stringChar)
-            {
+            } else if (m_buffer[m_pos] == '\\' && m_buffer[m_pos + 1] == stringChar) {
                 m_pos += 2;
-            }
-            else
-            {
+            } else {
                 if (m_buffer[m_pos] == '\n')
                     m_lineNum++;
                 m_pos++;
             }
-        }
-        else
-        {
+        } else {
             SkipWhitespace();
             CheckInclude();
             CheckIncbin();
@@ -99,10 +87,8 @@ void CFile::FindIncbins()
     }
 }
 
-bool CFile::ConsumeHorizontalWhitespace()
-{
-    if (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' ')
-    {
+bool CFile::ConsumeHorizontalWhitespace() {
+    if (m_buffer[m_pos] == '\t' || m_buffer[m_pos] == ' ') {
         m_pos++;
         return true;
     }
@@ -110,17 +96,14 @@ bool CFile::ConsumeHorizontalWhitespace()
     return false;
 }
 
-bool CFile::ConsumeNewline()
-{
-    if (m_buffer[m_pos] == '\n')
-    {
+bool CFile::ConsumeNewline() {
+    if (m_buffer[m_pos] == '\n') {
         m_pos++;
         m_lineNum++;
         return true;
     }
 
-    if (m_buffer[m_pos] == '\r' && m_buffer[m_pos + 1] == '\n')
-    {
+    if (m_buffer[m_pos] == '\r' && m_buffer[m_pos + 1] == '\n') {
         m_pos += 2;
         m_lineNum++;
         return true;
@@ -129,13 +112,10 @@ bool CFile::ConsumeNewline()
     return false;
 }
 
-bool CFile::ConsumeComment()
-{
-    if (m_buffer[m_pos] == '/' && m_buffer[m_pos + 1] == '*')
-    {
+bool CFile::ConsumeComment() {
+    if (m_buffer[m_pos] == '/' && m_buffer[m_pos + 1] == '*') {
         m_pos += 2;
-        while (m_buffer[m_pos] != '*' || m_buffer[m_pos + 1] != '/')
-        {
+        while (m_buffer[m_pos] != '*' || m_buffer[m_pos + 1] != '/') {
             if (m_buffer[m_pos] == 0)
                 return false;
             if (!ConsumeNewline())
@@ -143,12 +123,9 @@ bool CFile::ConsumeComment()
         }
         m_pos += 2;
         return true;
-    }
-    else if (m_buffer[m_pos] == '/' && m_buffer[m_pos + 1] == '/')
-    {
+    } else if (m_buffer[m_pos] == '/' && m_buffer[m_pos + 1] == '/') {
         m_pos += 2;
-        while (!ConsumeNewline())
-        {
+        while (!ConsumeNewline()) {
             if (m_buffer[m_pos] == 0)
                 return false;
             m_pos++;
@@ -159,14 +136,12 @@ bool CFile::ConsumeComment()
     return false;
 }
 
-void CFile::SkipWhitespace()
-{
+void CFile::SkipWhitespace() {
     while (ConsumeHorizontalWhitespace() || ConsumeNewline() || ConsumeComment())
         ;
 }
 
-bool CFile::CheckIdentifier(const std::string& ident)
-{
+bool CFile::CheckIdentifier(const std::string& ident) {
     unsigned int i;
 
     for (i = 0; i < ident.length() && m_pos + i < (unsigned)m_size; i++)
@@ -176,15 +151,13 @@ bool CFile::CheckIdentifier(const std::string& ident)
     return (i == ident.length());
 }
 
-void CFile::CheckInclude()
-{
+void CFile::CheckInclude() {
     if (m_buffer[m_pos] != '#')
         return;
 
     std::string ident = "#include";
 
-    if (!CheckIdentifier(ident))
-    {
+    if (!CheckIdentifier(ident)) {
         return;
     }
 
@@ -199,27 +172,19 @@ void CFile::CheckInclude()
     }
 }
 
-void CFile::CheckIncbin()
-{
+void CFile::CheckIncbin() {
     // Optimization: assume most lines are not incbins
-    if (!(m_buffer[m_pos+0] == 'I'
-       && m_buffer[m_pos+1] == 'N'
-       && m_buffer[m_pos+2] == 'C'
-       && m_buffer[m_pos+3] == 'B'
-       && m_buffer[m_pos+4] == 'I'
-       && m_buffer[m_pos+5] == 'N'
-       && m_buffer[m_pos+6] == '_'))
-    {
-            return;
+    if (!(m_buffer[m_pos + 0] == 'I' && m_buffer[m_pos + 1] == 'N' && m_buffer[m_pos + 2] == 'C' &&
+          m_buffer[m_pos + 3] == 'B' && m_buffer[m_pos + 4] == 'I' && m_buffer[m_pos + 5] == 'N' &&
+          m_buffer[m_pos + 6] == '_')) {
+        return;
     }
 
     std::string idents[6] = { "INCBIN_S8", "INCBIN_U8", "INCBIN_S16", "INCBIN_U16", "INCBIN_S32", "INCBIN_U32" };
     int incbinType = -1;
 
-    for (int i = 0; i < 6; i++)
-    {
-        if (CheckIdentifier(idents[i]))
-        {
+    for (int i = 0; i < 6; i++) {
+        if (CheckIdentifier(idents[i])) {
             incbinType = i;
             break;
         }
@@ -235,8 +200,7 @@ void CFile::CheckIncbin()
 
     SkipWhitespace();
 
-    if (m_buffer[m_pos] != '(')
-    {
+    if (m_buffer[m_pos] != '(') {
         m_pos = oldPos;
         m_lineNum = oldLineNum;
         return;
@@ -244,8 +208,7 @@ void CFile::CheckIncbin()
 
     m_pos++;
 
-    while (true)
-    {
+    while (true) {
         SkipWhitespace();
 
         std::string path = ReadPath();
@@ -264,15 +227,11 @@ void CFile::CheckIncbin()
         FATAL_INPUT_ERROR("expected ')'");
 
     m_pos++;
-
 }
 
-std::string CFile::ReadPath()
-{
-    if (m_buffer[m_pos] != '"')
-    {
-        if (m_buffer[m_pos] == '<')
-        {
+std::string CFile::ReadPath() {
+    if (m_buffer[m_pos] != '"') {
+        if (m_buffer[m_pos] == '<') {
             return std::string();
         }
         FATAL_INPUT_ERROR("expected '\"' or '<'");
@@ -282,10 +241,8 @@ std::string CFile::ReadPath()
 
     int startPos = m_pos;
 
-    while (m_buffer[m_pos] != '"')
-    {
-        if (m_buffer[m_pos] == 0)
-        {
+    while (m_buffer[m_pos] != '"') {
+        if (m_buffer[m_pos] == 0) {
             if (m_pos >= m_size)
                 FATAL_INPUT_ERROR("unexpected EOF in path string");
             else
diff --git a/tools/src/scaninc/c_file.h b/tools/src/scaninc/c_file.h
index 618901b8..2d4fc688 100755..100644
--- a/tools/src/scaninc/c_file.h
+++ b/tools/src/scaninc/c_file.h
@@ -26,17 +26,20 @@
 #include <memory>
 #include "scaninc.h"
 
-class CFile
-{
-public:
+class CFile {
+  public:
     CFile(std::string path);
     ~CFile();
     void FindIncbins();
-    const std::set<std::string>& GetIncbins() { return m_incbins; }
-    const std::set<std::string>& GetIncludes() { return m_includes; }
+    const std::set<std::string>& GetIncbins() {
+        return m_incbins;
+    }
+    const std::set<std::string>& GetIncludes() {
+        return m_includes;
+    }
 
-private:
-    char *m_buffer;
+  private:
+    char* m_buffer;
     int m_pos;
     int m_size;
     int m_lineNum;
diff --git a/tools/src/scaninc/scaninc.cpp b/tools/src/scaninc/scaninc.cpp
index 1bf7feb5..e77982c8 100755..100644
--- a/tools/src/scaninc/scaninc.cpp
+++ b/tools/src/scaninc/scaninc.cpp
@@ -27,9 +27,8 @@
 #include "scaninc.h"
 #include "source_file.h"
 
-bool CanOpenFile(std::string path)
-{
-    FILE *fp = std::fopen(path.c_str(), "rb");
+bool CanOpenFile(std::string path) {
+    FILE* fp = std::fopen(path.c_str(), "rb");
 
     if (fp == NULL)
         return false;
@@ -38,10 +37,9 @@ bool CanOpenFile(std::string path)
     return true;
 }
 
-const char *const USAGE = "Usage: scaninc [-I INCLUDE_PATH] FILE_PATH\n";
+const char* const USAGE = "Usage: scaninc [-I INCLUDE_PATH] FILE_PATH\n";
 
-int main(int argc, char **argv)
-{
+int main(int argc, char** argv) {
     std::queue<std::string> filesToProcess;
     std::set<std::string> dependencies;
 
@@ -50,26 +48,20 @@ int main(int argc, char **argv)
     argc--;
     argv++;
 
-    while (argc > 1)
-    {
+    while (argc > 1) {
         std::string arg(argv[0]);
-        if (arg.substr(0, 2) == "-I")
-        {
+        if (arg.substr(0, 2) == "-I") {
             std::string includeDir = arg.substr(2);
-            if (includeDir.empty())
-            {
+            if (includeDir.empty()) {
                 argc--;
                 argv++;
                 includeDir = std::string(argv[0]);
             }
-            if (!includeDir.empty() && includeDir.back() != '/')
-            {
+            if (!includeDir.empty() && includeDir.back() != '/') {
                 includeDir += '/';
             }
             includeDirs.push_back(includeDir);
-        }
-        else
-        {
+        } else {
             FATAL_ERROR(USAGE);
         }
         argc--;
@@ -84,36 +76,28 @@ int main(int argc, char **argv)
 
     filesToProcess.push(initialPath);
 
-    while (!filesToProcess.empty())
-    {
+    while (!filesToProcess.empty()) {
         std::string filePath = filesToProcess.front();
         SourceFile file(filePath);
         filesToProcess.pop();
 
         includeDirs.push_back(file.GetSrcDir());
-        for (auto incbin : file.GetIncbins())
-        {
+        for (auto incbin : file.GetIncbins()) {
             // Search for the incbin in the include directories as well.
-            for (auto includeDir : includeDirs)
-            {
+            for (auto includeDir : includeDirs) {
                 std::string path(includeDir + incbin);
-                if (CanOpenFile(path))
-                {
+                if (CanOpenFile(path)) {
                     dependencies.insert(path);
                     break;
                 }
             }
         }
-        for (auto include : file.GetIncludes())
-        {
-            for (auto includeDir : includeDirs)
-            {
+        for (auto include : file.GetIncludes()) {
+            for (auto includeDir : includeDirs) {
                 std::string path(includeDir + include);
-                if (CanOpenFile(path))
-                {
+                if (CanOpenFile(path)) {
                     bool inserted = dependencies.insert(path).second;
-                    if (inserted)
-                    {
+                    if (inserted) {
                         filesToProcess.push(path);
                     }
                     break;
@@ -123,8 +107,7 @@ int main(int argc, char **argv)
         includeDirs.pop_back();
     }
 
-    for (const std::string &path : dependencies)
-    {
+    for (const std::string& path : dependencies) {
         std::printf("%s\n", path.c_str());
     }
 }
diff --git a/tools/src/scaninc/scaninc.h b/tools/src/scaninc/scaninc.h
index 30cc9611..92bff804 100755..100644
--- a/tools/src/scaninc/scaninc.h
+++ b/tools/src/scaninc/scaninc.h
@@ -26,31 +26,31 @@
 
 #ifdef _MSC_VER
 
-#define FATAL_INPUT_ERROR(format, ...)                                        \
-do {                                                                          \
-    fprintf(stderr, "%s:%d " format, m_path.c_str(), m_lineNum, __VA_ARGS__); \
-    exit(1);                                                                  \
-} while (0)
-
-#define FATAL_ERROR(format, ...)          \
-do {                                      \
-    fprintf(stderr, format, __VA_ARGS__); \
-    exit(1);                              \
-} while (0)
+#define FATAL_INPUT_ERROR(format, ...)                                            \
+    do {                                                                          \
+        fprintf(stderr, "%s:%d " format, m_path.c_str(), m_lineNum, __VA_ARGS__); \
+        exit(1);                                                                  \
+    } while (0)
+
+#define FATAL_ERROR(format, ...)              \
+    do {                                      \
+        fprintf(stderr, format, __VA_ARGS__); \
+        exit(1);                              \
+    } while (0)
 
 #else
 
-#define FATAL_INPUT_ERROR(format, ...)                                          \
-do {                                                                            \
-    fprintf(stderr, "%s:%d " format, m_path.c_str(), m_lineNum, ##__VA_ARGS__); \
-    exit(1);                                                                    \
-} while (0)
-
-#define FATAL_ERROR(format, ...)            \
-do {                                        \
-    fprintf(stderr, format, ##__VA_ARGS__); \
-    exit(1);                                \
-} while (0)
+#define FATAL_INPUT_ERROR(format, ...)                                              \
+    do {                                                                            \
+        fprintf(stderr, "%s:%d " format, m_path.c_str(), m_lineNum, ##__VA_ARGS__); \
+        exit(1);                                                                    \
+    } while (0)
+
+#define FATAL_ERROR(format, ...)                \
+    do {                                        \
+        fprintf(stderr, format, ##__VA_ARGS__); \
+        exit(1);                                \
+    } while (0)
 
 #endif // _MSC_VER
 
diff --git a/tools/src/scaninc/source_file.cpp b/tools/src/scaninc/source_file.cpp
index f23ff6db..12daa0c6 100755..100644
--- a/tools/src/scaninc/source_file.cpp
+++ b/tools/src/scaninc/source_file.cpp
@@ -21,9 +21,7 @@
 #include <new>
 #include "source_file.h"
 
-
-SourceFileType GetFileType(std::string& path)
-{
+SourceFileType GetFileType(std::string& path) {
     std::size_t pos = path.find_last_of('.');
 
     if (pos == std::string::npos)
@@ -41,13 +39,12 @@ SourceFileType GetFileType(std::string& path)
         return SourceFileType::Inc;
     else
         FATAL_ERROR("Unrecognized extension \"%s\"\n", extension.c_str());
-    
+
     // Unreachable
     return SourceFileType::Cpp;
 }
 
-std::string GetDir(std::string& path)
-{
+std::string GetDir(std::string& path) {
     std::size_t slash = path.rfind('/');
 
     if (slash != std::string::npos)
@@ -56,20 +53,15 @@ std::string GetDir(std::string& path)
         return std::string("");
 }
 
-SourceFile::SourceFile(std::string path)
-{
+SourceFile::SourceFile(std::string path) {
     m_file_type = GetFileType(path);
 
     m_src_dir = GetDir(path);
 
-    if (m_file_type == SourceFileType::Cpp
-            || m_file_type == SourceFileType::Header)
-    {
+    if (m_file_type == SourceFileType::Cpp || m_file_type == SourceFileType::Header) {
         new (&m_source_file.c_file) CFile(path);
         m_source_file.c_file.FindIncbins();
-    }
-    else
-    {
+    } else {
         AsmFile file(path);
         std::set<std::string> incbins;
         std::set<std::string> includes;
@@ -77,49 +69,40 @@ SourceFile::SourceFile(std::string path)
         IncDirectiveType incDirectiveType;
         std::string outputPath;
 
-        while ((incDirectiveType = file.ReadUntilIncDirective(outputPath)) != IncDirectiveType::None)
-        {
+        while ((incDirectiveType = file.ReadUntilIncDirective(outputPath)) != IncDirectiveType::None) {
             if (incDirectiveType == IncDirectiveType::Include)
                 includes.insert(outputPath);
             else
                 incbins.insert(outputPath);
         }
-        
-        new (&m_source_file.asm_wrapper) SourceFile::InnerUnion::AsmWrapper{incbins, includes};
+
+        new (&m_source_file.asm_wrapper) SourceFile::InnerUnion::AsmWrapper{ incbins, includes };
     }
 }
 
-SourceFile::~SourceFile()
-{
-    if (m_file_type == SourceFileType::Cpp || m_file_type == SourceFileType::Header)
-    {
+SourceFile::~SourceFile() {
+    if (m_file_type == SourceFileType::Cpp || m_file_type == SourceFileType::Header) {
         m_source_file.c_file.~CFile();
-    }
-    else
-    {
+    } else {
         m_source_file.asm_wrapper.asm_incbins.~set();
         m_source_file.asm_wrapper.asm_includes.~set();
     }
 }
 
-const std::set<std::string>& SourceFile::GetIncbins()
-{
+const std::set<std::string>& SourceFile::GetIncbins() {
     if (m_file_type == SourceFileType::Cpp || m_file_type == SourceFileType::Header)
         return m_source_file.c_file.GetIncbins();
     else
         return m_source_file.asm_wrapper.asm_incbins;
 }
 
-const std::set<std::string>& SourceFile::GetIncludes()
-{
+const std::set<std::string>& SourceFile::GetIncludes() {
     if (m_file_type == SourceFileType::Cpp || m_file_type == SourceFileType::Header)
         return m_source_file.c_file.GetIncludes();
     else
         return m_source_file.asm_wrapper.asm_includes;
 }
 
-std::string& SourceFile::GetSrcDir()
-{
+std::string& SourceFile::GetSrcDir() {
     return m_src_dir;
 }
-
diff --git a/tools/src/scaninc/source_file.h b/tools/src/scaninc/source_file.h
index f7b6412b..76a09d8c 100755..100644
--- a/tools/src/scaninc/source_file.h
+++ b/tools/src/scaninc/source_file.h
@@ -26,32 +26,24 @@
 #include "asm_file.h"
 #include "c_file.h"
 
-enum class SourceFileType
-{
-    Cpp,
-    Header,
-    Asm,
-    Inc
-};
+enum class SourceFileType { Cpp, Header, Asm, Inc };
 
 SourceFileType GetFileType(std::string& path);
 
-class SourceFile
-{
-public:
-
+class SourceFile {
+  public:
     SourceFile(std::string path);
     ~SourceFile();
     SourceFile(SourceFile const&) = delete;
     SourceFile(SourceFile&&) = delete;
-    SourceFile& operator =(SourceFile const&) = delete;
-    SourceFile& operator =(SourceFile&&) = delete;
+    SourceFile& operator=(SourceFile const&) = delete;
+    SourceFile& operator=(SourceFile&&) = delete;
     bool HasIncbins();
     const std::set<std::string>& GetIncbins();
     const std::set<std::string>& GetIncludes();
     std::string& GetSrcDir();
 
-private:
+  private:
     union InnerUnion {
         CFile c_file;
         struct AsmWrapper {
@@ -60,12 +52,11 @@ private:
         } asm_wrapper;
 
         // Construction and destruction handled by SourceFile.
-        InnerUnion() {};
-        ~InnerUnion() {};
+        InnerUnion(){};
+        ~InnerUnion(){};
     } m_source_file;
     SourceFileType m_file_type;
     std::string m_src_dir;
 };
 
 #endif // SOURCE_FILE_H
-
diff --git a/tools/src/tmc_strings/main.cpp b/tools/src/tmc_strings/main.cpp
index 6490113a..7f5bbf22 100644
--- a/tools/src/tmc_strings/main.cpp
+++ b/tools/src/tmc_strings/main.cpp
@@ -4,522 +4,339 @@
 
 using namespace std::string_literals;
 using json = nlohmann::json;
-using u8   = std::uint8_t;
-using u16  = std::uint16_t;
-using u32  = std::uint32_t;
+using u8 = std::uint8_t;
+using u16 = std::uint16_t;
+using u32 = std::uint32_t;
 
 const u32 RomStartAddress = 0x8000000;
 
 namespace {
 
-    struct LanguageTable {
-        const char *name;
-        u32 address;
-    };
-
-    enum Color {
-        Color_White,
-        Color_Red,
-        Color_Green,
-        Color_Blue,
-        Color_Yellow,
-
-        Color_Count,
-    };
-
-    constexpr const char *const ColorStrings[] = {
-        "White",
-        "Red",
-        "Green",
-        "Blue",
-        "Yellow",
-    };
-
-    enum Input {
-        Input_A,
-        Input_B,
-        Input_Left,
-        Input_Right,
-        Input_DUp,
-        Input_DDown,
-        Input_DLeft,
-        Input_DRight,
-        Input_Dpad,
-        Input_Select,
-        Input_Start,
-
-        Input_Count,
-    };
-
-    constexpr const char *const InputStrings[] = {
-        "A",
-        "B",
-        "Left",
-        "Right",
-        "DUp",
-        "DDown",
-        "DLeft",
-        "DRight",
-        "Dpad",
-        "Select",
-        "Start",
-    };
-
-    const std::map<u8, std::string> CharConvertArray = {
-        {0x0a, "\n"},
-        {0x0d, "\r"},
-        {0x20, " "},
-        {0x21, "!"},
-        {0x22, "\""},
-        {0x23, "#"},
-        {0x24, "$"},
-        {0x25, "%"},
-        {0x26, "&"},
-        {0x27, "\'"},
-        {0x28, "("},
-        {0x29, ")"},
-        {0x2a, "*"},
-        {0x2b, "+"},
-        {0x2c, ","},
-        {0x2d, "-"},
-        {0x2e, "."},
-        {0x2f, "/"},
-        {0x30, "0"},
-        {0x31, "1"},
-        {0x32, "2"},
-        {0x33, "3"},
-        {0x34, "4"},
-        {0x35, "5"},
-        {0x36, "6"},
-        {0x37, "7"},
-        {0x38, "8"},
-        {0x39, "9"},
-        {0x3a, ":"},
-        {0x3b, ";"},
-        {0x3c, "<"},
-        {0x3d, "="},
-        {0x3e, ">"},
-        {0x3f, "?"},
-        {0x40, "@"},
-        {0x41, "A"},
-        {0x42, "B"},
-        {0x43, "C"},
-        {0x44, "D"},
-        {0x45, "E"},
-        {0x46, "F"},
-        {0x47, "G"},
-        {0x48, "H"},
-        {0x49, "I"},
-        {0x4a, "J"},
-        {0x4b, "K"},
-        {0x4c, "L"},
-        {0x4d, "M"},
-        {0x4e, "N"},
-        {0x4f, "O"},
-        {0x50, "P"},
-        {0x51, "Q"},
-        {0x52, "R"},
-        {0x53, "S"},
-        {0x54, "T"},
-        {0x55, "U"},
-        {0x56, "V"},
-        {0x57, "W"},
-        {0x58, "X"},
-        {0x59, "Y"},
-        {0x5a, "Z"},
-        {0x5b, "["},
-        {0x5c, "\'"},
-        {0x5d, "]"},
-        {0x5e, "^"},
-        {0x5f, "_"},
-        {0x60, "`"},
-        {0x61, "a"},
-        {0x62, "b"},
-        {0x63, "c"},
-        {0x64, "d"},
-        {0x65, "e"},
-        {0x66, "f"},
-        {0x67, "g"},
-        {0x68, "h"},
-        {0x69, "i"},
-        {0x6a, "j"},
-        {0x6b, "k"},
-        {0x6c, "l"},
-        {0x6d, "m"},
-        {0x6e, "n"},
-        {0x6f, "o"},
-        {0x70, "p"},
-        {0x71, "q"},
-        {0x72, "r"},
-        {0x73, "s"},
-        {0x74, "t"},
-        {0x75, "u"},
-        {0x76, "v"},
-        {0x77, "w"},
-        {0x78, "x"},
-        {0x79, "y"},
-        {0x7a, "z"},
-        {0x82, ","},
-        {0x84, "„"},
-        {0x85, "⋯"},
-        {0x8A, "Š"},
-        {0x8B, "‹"},
-        {0x8C, "Œ"},
-        {0x8E, "Ž"},
-        {0x91, "‘"},
-        {0x92, "’"},
-        {0x93, "“"},
-        {0x94, "”"},
-        {0x95, "·"},
-        {0x99, "™"},
-        {0x9A, "š"},
-        {0x9B, "›"},
-        {0x9C, "œ"},
-        {0x9E, "ž"},
-        {0x9F, "Ÿ"},
-        {0xA1, "¡"},
-        {0xA3, "♪"},
-        {0xAA, "ª"},
-        {0xAB, "«"},
-        {0xB0, "º"},
-        {0xB4, "'"},
-        {0xB7, "´"},
-        {0xBA, "º"},
-        {0xBB, "»"},
-        {0xBF, "¿"},
-        {0xC0, "À"},
-        {0xC1, "Á"},
-        {0xC2, "Â"},
-        {0xC3, "Ã"},
-        {0xC4, "Ä"},
-        {0xC5, "Å"},
-        {0xC6, "Æ"},
-        {0xC7, "Ç"},
-        {0xC8, "È"},
-        {0xC9, "É"},
-        {0xCA, "Ê"},
-        {0xCB, "Ë"},
-        {0xCC, "Ì"},
-        {0xCD, "Í"},
-        {0xCE, "Î"},
-        {0xCF, "Ï"},
-        {0xD0, "Đ"},
-        {0xD1, "Ñ"},
-        {0xD2, "Ò"},
-        {0xD3, "Ó"},
-        {0xD4, "Ô"},
-        {0xD5, "Õ"},
-        {0xD6, "Ö"},
-        {0xD7, "×"},
-        {0xD8, "Ø"},
-        {0xD9, "Ù"},
-        {0xDA, "Ú"},
-        {0xDB, "Û"},
-        {0xDC, "Ü"},
-        {0xDD, "Ý"},
-        {0xDE, "Þ"},
-        {0xDF, "β"},
-        {0xE0, "à"},
-        {0xE1, "á"},
-        {0xE2, "â"},
-        {0xE3, "ã"},
-        {0xE4, "ä"},
-        {0xE5, "å"},
-        {0xE6, "æ"},
-        {0xE7, "ç"},
-        {0xE8, "è"},
-        {0xE9, "é"},
-        {0xEA, "ê"},
-        {0xEB, "ë"},
-        {0xEC, "ì"},
-        {0xED, "í"},
-        {0xEE, "î"},
-        {0xEF, "ï"},
-        {0xF0, "ð"},
-        {0xF1, "ñ"},
-        {0xF2, "ò"},
-        {0xF3, "ó"},
-        {0xF4, "ô"},
-        {0xF5, "õ"},
-        {0xF6, "ö"},
-        {0xF7, "÷"},
-        {0xF8, "ø"},
-        {0xF9, "ù"},
-        {0xFA, "ú"},
-        {0xFB, "û"},
-        {0xFC, "ü"},
-        {0xFD, "ý"},
-        {0xFE, "þ"},
-        {0xFF, "ÿ"},
-    };
-
-    using ConvertFunction = std::string (*const)(const char *&);
-
-    std::string Unk1Handler(const char *&ptr) {
-        u8 a = *ptr++;
-        return fmt::format("{{01:{:02X}}}", a);
-    }
+struct LanguageTable {
+    const char* name;
+    u32 address;
+};
 
-    std::string ColorHandler(const char *&ptr) {
-        u8 color = *ptr++;
-        if (color >= Color_Count)
-            throw std::runtime_error(ptr);
-        return fmt::format("{{Color:{}}}", ColorStrings[color]);
-    }
+enum Color {
+    Color_White,
+    Color_Red,
+    Color_Green,
+    Color_Blue,
+    Color_Yellow,
 
-    std::string SoundHandler(const char *&ptr) {
-        u8 a = *ptr++;
-        u8 b = *ptr++;
-        return fmt::format("{{Sound:{:02X}:{:02X}}}", a, b);
-    }
+    Color_Count,
+};
 
-    std::string Unk4Handler(const char *&ptr) {
-        u8 a = *ptr++;
-        if (a == 0x10) {
-            u8 b = *ptr++;
-            return fmt::format("{{04:{:02X}:{:02X}}}", a, b);
-        } else {
-            return fmt::format("{{04:{:02X}}}", a);
-        }
-    }
+constexpr const char* const ColorStrings[] = {
+    "White", "Red", "Green", "Blue", "Yellow",
+};
 
-    std::string ChoiceHandler(const char *&ptr) {
-        u8 category = *ptr++;
-        if (category == 0xff) {
-            return "{Choice:FF}";
-        } else {
-            u8 action = *ptr++;
-            return fmt::format("{{Choice:{:02X}:{:02X}}}", category, action);
-        }
-    }
+enum Input {
+    Input_A,
+    Input_B,
+    Input_Left,
+    Input_Right,
+    Input_DUp,
+    Input_DDown,
+    Input_DLeft,
+    Input_DRight,
+    Input_Dpad,
+    Input_Select,
+    Input_Start,
+
+    Input_Count,
+};
 
-    std::string VariableHandler(const char *&ptr) {
-        u8 idx = *ptr++;
-        if (idx == 0) {
-            return "{Player}";
-        } else {
-            return fmt::format("{{Var:{:X}}}", idx);
-        }
-    }
+constexpr const char* const InputStrings[] = {
+    "A", "B", "Left", "Right", "DUp", "DDown", "DLeft", "DRight", "Dpad", "Select", "Start",
+};
+
+const std::map<u8, std::string> CharConvertArray = {
+    { 0x0a, "\n" }, { 0x0d, "\r" }, { 0x20, " " },  { 0x21, "!" }, { 0x22, "\"" }, { 0x23, "#" }, { 0x24, "$" },
+    { 0x25, "%" },  { 0x26, "&" },  { 0x27, "\'" }, { 0x28, "(" }, { 0x29, ")" },  { 0x2a, "*" }, { 0x2b, "+" },
+    { 0x2c, "," },  { 0x2d, "-" },  { 0x2e, "." },  { 0x2f, "/" }, { 0x30, "0" },  { 0x31, "1" }, { 0x32, "2" },
+    { 0x33, "3" },  { 0x34, "4" },  { 0x35, "5" },  { 0x36, "6" }, { 0x37, "7" },  { 0x38, "8" }, { 0x39, "9" },
+    { 0x3a, ":" },  { 0x3b, ";" },  { 0x3c, "<" },  { 0x3d, "=" }, { 0x3e, ">" },  { 0x3f, "?" }, { 0x40, "@" },
+    { 0x41, "A" },  { 0x42, "B" },  { 0x43, "C" },  { 0x44, "D" }, { 0x45, "E" },  { 0x46, "F" }, { 0x47, "G" },
+    { 0x48, "H" },  { 0x49, "I" },  { 0x4a, "J" },  { 0x4b, "K" }, { 0x4c, "L" },  { 0x4d, "M" }, { 0x4e, "N" },
+    { 0x4f, "O" },  { 0x50, "P" },  { 0x51, "Q" },  { 0x52, "R" }, { 0x53, "S" },  { 0x54, "T" }, { 0x55, "U" },
+    { 0x56, "V" },  { 0x57, "W" },  { 0x58, "X" },  { 0x59, "Y" }, { 0x5a, "Z" },  { 0x5b, "[" }, { 0x5c, "\'" },
+    { 0x5d, "]" },  { 0x5e, "^" },  { 0x5f, "_" },  { 0x60, "`" }, { 0x61, "a" },  { 0x62, "b" }, { 0x63, "c" },
+    { 0x64, "d" },  { 0x65, "e" },  { 0x66, "f" },  { 0x67, "g" }, { 0x68, "h" },  { 0x69, "i" }, { 0x6a, "j" },
+    { 0x6b, "k" },  { 0x6c, "l" },  { 0x6d, "m" },  { 0x6e, "n" }, { 0x6f, "o" },  { 0x70, "p" }, { 0x71, "q" },
+    { 0x72, "r" },  { 0x73, "s" },  { 0x74, "t" },  { 0x75, "u" }, { 0x76, "v" },  { 0x77, "w" }, { 0x78, "x" },
+    { 0x79, "y" },  { 0x7a, "z" },  { 0x82, "," },  { 0x84, "„" }, { 0x85, "⋯" },  { 0x8A, "Š" }, { 0x8B, "‹" },
+    { 0x8C, "Œ" },  { 0x8E, "Ž" },  { 0x91, "‘" },  { 0x92, "’" }, { 0x93, "“" },  { 0x94, "”" }, { 0x95, "·" },
+    { 0x99, "™" },  { 0x9A, "š" },  { 0x9B, "›" },  { 0x9C, "œ" }, { 0x9E, "ž" },  { 0x9F, "Ÿ" }, { 0xA1, "¡" },
+    { 0xA3, "♪" },  { 0xAA, "ª" },  { 0xAB, "«" },  { 0xB0, "º" }, { 0xB4, "'" },  { 0xB7, "´" }, { 0xBA, "º" },
+    { 0xBB, "»" },  { 0xBF, "¿" },  { 0xC0, "À" },  { 0xC1, "Á" }, { 0xC2, "Â" },  { 0xC3, "Ã" }, { 0xC4, "Ä" },
+    { 0xC5, "Å" },  { 0xC6, "Æ" },  { 0xC7, "Ç" },  { 0xC8, "È" }, { 0xC9, "É" },  { 0xCA, "Ê" }, { 0xCB, "Ë" },
+    { 0xCC, "Ì" },  { 0xCD, "Í" },  { 0xCE, "Î" },  { 0xCF, "Ï" }, { 0xD0, "Đ" },  { 0xD1, "Ñ" }, { 0xD2, "Ò" },
+    { 0xD3, "Ó" },  { 0xD4, "Ô" },  { 0xD5, "Õ" },  { 0xD6, "Ö" }, { 0xD7, "×" },  { 0xD8, "Ø" }, { 0xD9, "Ù" },
+    { 0xDA, "Ú" },  { 0xDB, "Û" },  { 0xDC, "Ü" },  { 0xDD, "Ý" }, { 0xDE, "Þ" },  { 0xDF, "β" }, { 0xE0, "à" },
+    { 0xE1, "á" },  { 0xE2, "â" },  { 0xE3, "ã" },  { 0xE4, "ä" }, { 0xE5, "å" },  { 0xE6, "æ" }, { 0xE7, "ç" },
+    { 0xE8, "è" },  { 0xE9, "é" },  { 0xEA, "ê" },  { 0xEB, "ë" }, { 0xEC, "ì" },  { 0xED, "í" }, { 0xEE, "î" },
+    { 0xEF, "ï" },  { 0xF0, "ð" },  { 0xF1, "ñ" },  { 0xF2, "ò" }, { 0xF3, "ó" },  { 0xF4, "ô" }, { 0xF5, "õ" },
+    { 0xF6, "ö" },  { 0xF7, "÷" },  { 0xF8, "ø" },  { 0xF9, "ù" }, { 0xFA, "ú" },  { 0xFB, "û" }, { 0xFC, "ü" },
+    { 0xFD, "ý" },  { 0xFE, "þ" },  { 0xFF, "ÿ" },
+};
+
+using ConvertFunction = std::string (*const)(const char*&);
+
+std::string Unk1Handler(const char*& ptr) {
+    u8 a = *ptr++;
+    return fmt::format("{{01:{:02X}}}", a);
+}
 
-    std::string Unk7Handler(const char *&ptr) {
-        u8 a = *ptr++;
+std::string ColorHandler(const char*& ptr) {
+    u8 color = *ptr++;
+    if (color >= Color_Count)
+        throw std::runtime_error(ptr);
+    return fmt::format("{{Color:{}}}", ColorStrings[color]);
+}
+
+std::string SoundHandler(const char*& ptr) {
+    u8 a = *ptr++;
+    u8 b = *ptr++;
+    return fmt::format("{{Sound:{:02X}:{:02X}}}", a, b);
+}
+
+std::string Unk4Handler(const char*& ptr) {
+    u8 a = *ptr++;
+    if (a == 0x10) {
         u8 b = *ptr++;
-        return fmt::format("{{07:{:02X}:{:02X}}}", a, b);
+        return fmt::format("{{04:{:02X}:{:02X}}}", a, b);
+    } else {
+        return fmt::format("{{04:{:02X}}}", a);
     }
+}
 
-    std::string Unk8Handler(const char *&ptr) {
-        u8 a = *ptr++;
-        if (a != 0xff)
-            throw std::runtime_error("unmatched unk8: "s + std::to_string(a));
-        return "{08:FF}";
+std::string ChoiceHandler(const char*& ptr) {
+    u8 category = *ptr++;
+    if (category == 0xff) {
+        return "{Choice:FF}";
+    } else {
+        u8 action = *ptr++;
+        return fmt::format("{{Choice:{:02X}:{:02X}}}", category, action);
     }
+}
 
-    std::string Unk9Handler(const char *&ptr) {
-        u8 a = *ptr++;
-        if (a != 0x78 && a != 0x00)
-            throw std::runtime_error("unmatched unk8: "s + std::to_string(a));
-        return fmt::format("{{09:{:02X}}}", a);
+std::string VariableHandler(const char*& ptr) {
+    u8 idx = *ptr++;
+    if (idx == 0) {
+        return "{Player}";
+    } else {
+        return fmt::format("{{Var:{:X}}}", idx);
     }
+}
 
-    std::string InputHandler(const char *&ptr) {
-        u8 key = *ptr++;
-        if (key > 8)
-            throw std::runtime_error("unmatched key: "s + std::to_string(key));
-        return fmt::format("{{Key:{}}}", InputStrings[key]);
-    }
+std::string Unk7Handler(const char*& ptr) {
+    u8 a = *ptr++;
+    u8 b = *ptr++;
+    return fmt::format("{{07:{:02X}:{:02X}}}", a, b);
+}
 
-    std::string SymbolHandler(const char *&ptr) {
-        u8 a = *ptr++;
-        return fmt::format("{{Symbol:{:02X}}}", a);
-    }
+std::string Unk8Handler(const char*& ptr) {
+    u8 a = *ptr++;
+    if (a != 0xff)
+        throw std::runtime_error("unmatched unk8: "s + std::to_string(a));
+    return "{08:FF}";
+}
 
-    const std::map<u8, ConvertFunction> FuncConvertArray = {
-        {0x01, Unk1Handler},
-        {0x02, ColorHandler},
-        {0x03, SoundHandler},
-        {0x04, Unk4Handler},
-        {0x05, ChoiceHandler},
-        {0x06, VariableHandler},
-        {0x07, Unk7Handler},
-        {0x08, Unk8Handler},
-        {0x09, Unk9Handler},
-        {0x0c, InputHandler},
-        {0x0f, SymbolHandler},
-    };
-
-    std::string ParseTMCString(const char *ptr) {
-        std::string ret;
-
-        while (*ptr) {
-            u8 c = *ptr++;
-
-            /* Convert character. */
-            {
-                const auto it = CharConvertArray.find(c);
-
-                if (it != std::end(CharConvertArray)) {
-                    ret += it->second;
-                    continue;
-                }
-            }
+std::string Unk9Handler(const char*& ptr) {
+    u8 a = *ptr++;
+    if (a != 0x78 && a != 0x00)
+        throw std::runtime_error("unmatched unk8: "s + std::to_string(a));
+    return fmt::format("{{09:{:02X}}}", a);
+}
 
-            /* Convert function. */
-            {
-                const auto it = FuncConvertArray.find(c);
+std::string InputHandler(const char*& ptr) {
+    u8 key = *ptr++;
+    if (key > 8)
+        throw std::runtime_error("unmatched key: "s + std::to_string(key));
+    return fmt::format("{{Key:{}}}", InputStrings[key]);
+}
 
-                if (it != std::end(FuncConvertArray)) {
-                    ret += it->second(ptr);
-                    continue;
-                }
-            }
+std::string SymbolHandler(const char*& ptr) {
+    u8 a = *ptr++;
+    return fmt::format("{{Symbol:{:02X}}}", a);
+}
+
+const std::map<u8, ConvertFunction> FuncConvertArray = {
+    { 0x01, Unk1Handler },   { 0x02, ColorHandler },    { 0x03, SoundHandler },  { 0x04, Unk4Handler },
+    { 0x05, ChoiceHandler }, { 0x06, VariableHandler }, { 0x07, Unk7Handler },   { 0x08, Unk8Handler },
+    { 0x09, Unk9Handler },   { 0x0c, InputHandler },    { 0x0f, SymbolHandler },
+};
+
+std::string ParseTMCString(const char* ptr) {
+    std::string ret;
+
+    while (*ptr) {
+        u8 c = *ptr++;
 
-            throw std::runtime_error(fmt::format("Unknown characters: {}", ptr));
+        /* Convert character. */
+        {
+            const auto it = CharConvertArray.find(c);
+
+            if (it != std::end(CharConvertArray)) {
+                ret += it->second;
+                continue;
+            }
         }
 
-        return ret;
-    }
+        /* Convert function. */
+        {
+            const auto it = FuncConvertArray.find(c);
 
-    using RevertFunction = void (*)(const char *&, char *&);
-
-    void ColorRevert(const char *&src, char *&dst) {
-        *dst++ = 0x02;
-        src++; // ':'
-        for (u32 i = 0; i < Color_Count; i++) {
-            const char *const color     = ColorStrings[i];
-            const std::size_t color_len = std::strlen(color);
-            if (std::strncmp(src, color, color_len) == 0) {
-                *dst++ = i;
-                src += color_len;
-                return;
+            if (it != std::end(FuncConvertArray)) {
+                ret += it->second(ptr);
+                continue;
             }
         }
 
-        throw std::runtime_error(fmt::format("Color not found: {}", src));
+        throw std::runtime_error(fmt::format("Unknown characters: {}", ptr));
     }
 
-    void SoundRevert(const char *&src, char *&dst) {
-        *dst++ = 0x03;
-        *dst++ = std::strtoul(++src, nullptr, 0x10);
-        src += 2;
-        *dst++ = std::strtoul(++src, nullptr, 0x10);
-        src += 2;
+    return ret;
+}
+
+using RevertFunction = void (*)(const char*&, char*&);
+
+void ColorRevert(const char*& src, char*& dst) {
+    *dst++ = 0x02;
+    src++; // ':'
+    for (u32 i = 0; i < Color_Count; i++) {
+        const char* const color = ColorStrings[i];
+        const std::size_t color_len = std::strlen(color);
+        if (std::strncmp(src, color, color_len) == 0) {
+            *dst++ = i;
+            src += color_len;
+            return;
+        }
     }
 
-    void ChoiceRevert(const char *&src, char *&dst) {
-        *dst++    = 0x05;
-        u8 choice = std::strtoul(++src, nullptr, 0x10);
+    throw std::runtime_error(fmt::format("Color not found: {}", src));
+}
 
-        *dst++ = choice;
-        src += 2;
+void SoundRevert(const char*& src, char*& dst) {
+    *dst++ = 0x03;
+    *dst++ = std::strtoul(++src, nullptr, 0x10);
+    src += 2;
+    *dst++ = std::strtoul(++src, nullptr, 0x10);
+    src += 2;
+}
 
-        if (choice == 0xff)
-            return;
+void ChoiceRevert(const char*& src, char*& dst) {
+    *dst++ = 0x05;
+    u8 choice = std::strtoul(++src, nullptr, 0x10);
 
-        *dst++ = std::strtoul(++src, nullptr, 0x10);
-        src += 2;
-    }
+    *dst++ = choice;
+    src += 2;
 
-    void PlayerRevert(const char *&src, char *&dst) {
-        *dst++ = 0x06;
-        *dst++ = 0x00;
+    if (choice == 0xff)
+        return;
 
-        (void)src;
-    }
+    *dst++ = std::strtoul(++src, nullptr, 0x10);
+    src += 2;
+}
 
-    void VariableRevert(const char *&src, char *&dst) {
-        *dst++ = 0x06;
-        src++; // ':'
+void PlayerRevert(const char*& src, char*& dst) {
+    *dst++ = 0x06;
+    *dst++ = 0x00;
 
-        *dst++ = std::strtoul(src, nullptr, 0x10);
-        src++;
-    }
+    (void)src;
+}
 
-    void KeyRevert(const char *&src, char *&dst) {
-        *dst++ = 0x0c;
-        src++; // ':'
-        for (u32 i = 0; i < Input_Count; i++) {
-            const char *const input     = InputStrings[i];
-            const std::size_t input_len = std::strlen(input);
-            if (std::strncmp(src, input, input_len) == 0) {
-                *dst++ = i;
-                src += input_len;
-                return;
-            }
-        }
+void VariableRevert(const char*& src, char*& dst) {
+    *dst++ = 0x06;
+    src++; // ':'
 
-        throw std::runtime_error(fmt::format("Input not found: {}", src));
+    *dst++ = std::strtoul(src, nullptr, 0x10);
+    src++;
+}
+
+void KeyRevert(const char*& src, char*& dst) {
+    *dst++ = 0x0c;
+    src++; // ':'
+    for (u32 i = 0; i < Input_Count; i++) {
+        const char* const input = InputStrings[i];
+        const std::size_t input_len = std::strlen(input);
+        if (std::strncmp(src, input, input_len) == 0) {
+            *dst++ = i;
+            src += input_len;
+            return;
+        }
     }
 
-    void SymbolRevert(const char *&src, char *&dst) {
-        *dst++ = 0x0f;
-        src++; // ':'
+    throw std::runtime_error(fmt::format("Input not found: {}", src));
+}
+
+void SymbolRevert(const char*& src, char*& dst) {
+    *dst++ = 0x0f;
+    src++; // ':'
 
-        *dst++ = std::strtoul(src, nullptr, 0x10);
-        src += 2;
-    }
+    *dst++ = std::strtoul(src, nullptr, 0x10);
+    src += 2;
+}
+
+const std::pair<std::string, RevertFunction> FuncRevertArray[] = {
+    { "Color", ColorRevert },  { "Sound", SoundRevert }, { "Choice", ChoiceRevert }, { "Player", PlayerRevert },
+    { "Var", VariableRevert }, { "Key", KeyRevert },     { "Symbol", SymbolRevert },
+};
 
-    const std::pair<std::string, RevertFunction> FuncRevertArray[] = {
-        {"Color", ColorRevert},
-        {"Sound", SoundRevert},
-        {"Choice", ChoiceRevert},
-        {"Player", PlayerRevert},
-        {"Var", VariableRevert},
-        {"Key", KeyRevert},
-        {"Symbol", SymbolRevert},
-    };
-
-    void WriteTMCString(char *&dst, const std::string &src) {
-        const char *ptr = src.data();
-
-        while (*ptr) {
-            /* Parse special */
-            {
-                if (*ptr == '{') {
-                    ptr++;
-                    const auto it = std::find_if(std::begin(FuncRevertArray), std::end(FuncRevertArray), [&](const auto &data) {
+void WriteTMCString(char*& dst, const std::string& src) {
+    const char* ptr = src.data();
+
+    while (*ptr) {
+        /* Parse special */
+        {
+            if (*ptr == '{') {
+                ptr++;
+                const auto it =
+                    std::find_if(std::begin(FuncRevertArray), std::end(FuncRevertArray), [&](const auto& data) {
                         return std::strncmp(ptr, data.first.c_str(), data.first.size()) == 0;
                     });
 
-                    if (it != std::end(FuncRevertArray)) {
-                        ptr += it->first.size();
-                        it->second(ptr, dst);
-                    } else {
-                        do {
-                            *dst++ = std::strtoul(ptr, nullptr, 0x10);
-                            ptr += 2;
-                        } while (*ptr == ':' && (ptr++, true));
-                    }
-
-                    if (*ptr != '}')
-                        throw std::runtime_error(fmt::format("unmatched characters: \"{}\"\n", ptr));
-
-                    ptr++;
-                    continue;
+                if (it != std::end(FuncRevertArray)) {
+                    ptr += it->first.size();
+                    it->second(ptr, dst);
+                } else {
+                    do {
+                        *dst++ = std::strtoul(ptr, nullptr, 0x10);
+                        ptr += 2;
+                    } while (*ptr == ':' && (ptr++, true));
                 }
+
+                if (*ptr != '}')
+                    throw std::runtime_error(fmt::format("unmatched characters: \"{}\"\n", ptr));
+
+                ptr++;
+                continue;
             }
+        }
 
-            /* Convert character. */
-            {
-                const auto it = std::find_if(std::begin(CharConvertArray), std::end(CharConvertArray), [ptr](const auto &data) {
+        /* Convert character. */
+        {
+            const auto it =
+                std::find_if(std::begin(CharConvertArray), std::end(CharConvertArray), [ptr](const auto& data) {
                     return std::strncmp(ptr, data.second.c_str(), data.second.length()) == 0;
                 });
 
-                if (it != std::end(CharConvertArray)) {
-                    ptr += it->second.size();
-                    *dst++ = it->first;
-                    continue;
-                }
+            if (it != std::end(CharConvertArray)) {
+                ptr += it->second.size();
+                *dst++ = it->first;
+                continue;
             }
-
-            throw std::runtime_error(fmt::format("unmatched characters: \"{}\"\n", ptr));
         }
-        *dst++ = '\0';
-    }
 
+        throw std::runtime_error(fmt::format("unmatched characters: \"{}\"\n", ptr));
+    }
+    *dst++ = '\0';
 }
 
-void ExtractStringTable(std::string &rom_path, const std::vector<LanguageTable> &tables) {
+} // namespace
+
+void ExtractStringTable(std::string& rom_path, const std::vector<LanguageTable>& tables) {
     const std::vector<char> rom = [&]() {
         std::vector<char> rom;
 
@@ -543,11 +360,9 @@ void ExtractStringTable(std::string &rom_path, const std::vector<LanguageTable>
         return rom;
     }();
 
-    auto ReadAbsolute = [&](u32 address) -> u32 {
-        return *(u32 *)&rom[address - RomStartAddress];
-    };
+    auto ReadAbsolute = [&](u32 address) -> u32 { return *(u32*)&rom[address - RomStartAddress]; };
 
-    for (auto &language : tables) {
+    for (auto& language : tables) {
         /* Get category table start. */
         const std::size_t table_start = language.address;
 
@@ -560,7 +375,7 @@ void ExtractStringTable(std::string &rom_path, const std::vector<LanguageTable>
 
         json j = json::array();
 
-        for (auto &category_offset : category_table) {
+        for (auto& category_offset : category_table) {
             /* Get string table start. */
             const std::size_t category_start = table_start + category_offset;
 
@@ -571,7 +386,7 @@ void ExtractStringTable(std::string &rom_path, const std::vector<LanguageTable>
             std::vector<u32> string_table(string_count);
             std::memcpy(&string_table[0], &rom[category_start - RomStartAddress], string_count * sizeof(u32));
 
-            auto &category = j.emplace_back();
+            auto& category = j.emplace_back();
 
             for (std::size_t l = 0; l < string_count; l++) {
                 /* Get string start. */
@@ -588,7 +403,7 @@ void ExtractStringTable(std::string &rom_path, const std::vector<LanguageTable>
     }
 }
 
-void PackStringTable(const std::string &src_path, const std::string &dst_path, const std::size_t out_size) {
+void PackStringTable(const std::string& src_path, const std::string& dst_path, const std::size_t out_size) {
     const json j = [&]() -> json {
         std::ifstream ifs(src_path);
 
@@ -603,16 +418,16 @@ void PackStringTable(const std::string &src_path, const std::string &dst_path, c
     std::vector<char> buffer(0x100000);
     std::uintptr_t root_start = (std::uintptr_t)buffer.data();
 
-    char *root_ptr = buffer.data();
-    char *table    = buffer.data() + j.size() * sizeof(u32);
+    char* root_ptr = buffer.data();
+    char* table = buffer.data() + j.size() * sizeof(u32);
 
-    for (auto &category : j) {
-        char *table_ptr = table;
-        char *str_start = table_ptr + category.size() * sizeof(u32);
-        char *str_ptr   = str_start;
-        for (auto &str_j : category) {
+    for (auto& category : j) {
+        char* table_ptr = table;
+        char* str_start = table_ptr + category.size() * sizeof(u32);
+        char* str_ptr = str_start;
+        for (auto& str_j : category) {
             /* Write string offset to table. */
-            *(u32 *)table_ptr = (std::uintptr_t)str_ptr - (std::uintptr_t)table;
+            *(u32*)table_ptr = (std::uintptr_t)str_ptr - (std::uintptr_t)table;
             table_ptr += sizeof(u32);
 
             auto str = str_j.get<std::string>();
@@ -628,7 +443,7 @@ void PackStringTable(const std::string &src_path, const std::string &dst_path, c
         }
 
         /* Write category offset to root table. */
-        *(u32 *)root_ptr = (std::uintptr_t)table - root_start;
+        *(u32*)root_ptr = (std::uintptr_t)table - root_start;
         root_ptr += sizeof(u32);
 
         table = str_ptr;
@@ -675,7 +490,7 @@ const std::vector<LanguageTable> LanguageTableEU = {
 
 #include <getopt.h>
 
-const char *progname;
+const char* progname;
 
 void usage() {
     fmt::print(stderr,
@@ -705,7 +520,7 @@ constexpr const struct option long_options[] = {
 };
 // clang-format on
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
     std::string src_path;
     std::string dst_path;
     std::size_t max_size = 0;