Merge pull request 'MM_Branch' (#10) from MM_Branch into main

Reviewed-on: #10

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "makefile.configureOnOpen": false
+}

.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: gcc.exe build active file",
+            "command": "C:\\ProgramData\\mingw64\\mingw64\\bin\\gcc.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        }
+    ],
+    "version": "2.0.0"
+}

imageInput.c

@@ -3,20 +3,214 @@
 #include <string.h>
 #include "imageInput.h"
 
+// Größe eines temporären Puffers
 #define BUFFER_SIZE 100
+
+// Fester Header-String, der am Anfang jeder gültigen Bilddatei stehen muss
 #define FILE_HEADER_STRING "__info2_image_file_format__"
 
-// TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei
+/*
-
+ * Prüft den Dateiheader und liest Bildanzahl, Breite und Höhe aus.
-// TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen
+ * Gibt 1 (true) zurück, wenn alles gültig ist, sonst 0 (false).
-GrayScaleImageSeries *readImages(const char *path)
+ */
+static int checkheader(FILE *path, unsigned short *count, unsigned short *width, unsigned short *height)
 {
-    GrayScaleImageSeries *series = NULL;
+    unsigned int headerlen = strlen(FILE_HEADER_STRING);
-    
+    unsigned char header[64];
+
+    // Prüfen, ob der Header-String in den Puffer passt
+    if (headerlen >= sizeof(header))
+    {
+        return 0;
+    }
+
+    // Header aus Datei lesen – muss exakt gleich lang sein
+    if (fread(header, 1, headerlen, path) != headerlen)
+    {
+        return 0;
+    }
+
+    // Header vergleichen – Datei muss mit FILE_HEADER_STRING beginnen
+    if (strncmp((char *)header, FILE_HEADER_STRING, headerlen) != 0)
+    {
+        return 0;
+    }
+
+    // Danach folgen in der Datei: count, width, height (je 2 Bytes)
+    if (fread(count, sizeof(unsigned short), 1, path) != 1)
+        return 0;
+
+    if (fread(width, sizeof(unsigned short), 1, path) != 1)
+        return 0;
+
+    if (fread(height, sizeof(unsigned short), 1, path) != 1)
+        return 0;
+
+    return 1;
+}
+
+/*
+ * Reserviert Speicher für eine Serie von Graustufenbildern.
+ * Legt:
+ *   - Hauptstruktur
+ *   - Array von Bildern
+ *   - Array von Labels
+ *   - Für jedes Bild einen Pixelpuffer
+ * an.
+ */
+static GrayScaleImageSeries *allocateSeries(unsigned short count, unsigned short width, unsigned short height)
+{
+    // Platz für die Gesamtstruktur anfordern
+    GrayScaleImageSeries *series = malloc(sizeof(GrayScaleImageSeries));
+    if (series == NULL)
+    {
+        return NULL;
+    }
+
+    series->count = count;
+
+    // Arrays für Bilder und Labels anlegen
+    series->images = calloc(count, sizeof(GrayScaleImage));
+    series->labels = calloc(count, sizeof(unsigned char));
+
+    if (series->images == NULL || series->labels == NULL)
+    {
+        return NULL;
+    }
+
+    // Jedem Bild Höhe, Breite und einen eigenen Pixelpuffer zuweisen
+    for (unsigned int i = 0; i < count; i++)
+    {
+        series->images[i].height = height;
+        series->images[i].width = width;
+
+        // Für jedes Bild einen Puffer anlegen: width * height Pixel
+        series->images[i].buffer = calloc(height * width, sizeof(GrayScalePixelType));
+
+        if (series->images[i].buffer == NULL)
+        {
+            // Falls ein Puffer fehlschlägt → alles bisherige wieder freigeben
+            clearSeries(series);
+            return NULL;
+        }
+    }
+
     return series;
 }
 
-// TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
+/*
+ * Liest die Pixeldaten und Labels aller Bilder aus der Datei.
+ * Reihenfolge in der Datei je Bild:
+ *      1. Pixelwerte (width*height Stück)
+ *      2. 1 Byte Label
+ */
+static int loadImageData(FILE *file, GrayScaleImageSeries *series, unsigned short count, unsigned short width, unsigned short height)
+{
+    for (unsigned int i = 0; i < count; i++)
+    {
+        size_t pixelCount = width * height;
+
+        // Pixeldaten in den Bildpuffer schreiben
+        if (fread(series->images[i].buffer, sizeof(GrayScalePixelType), pixelCount, file) != pixelCount)
+        {
+            return 0;
+        }
+
+        // Label lesen (1 Byte)
+        if (fread(&series->labels[i], sizeof(unsigned char), 1, file) != 1)
+        {
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+// Schliesst eine Datei, sofern sie geöffnet ist
+static void closefile(FILE *file)
+{
+    if (file != NULL)
+    {
+        fclose(file);
+    }
+}
+
+/*
+ * Hauptfunktion zum Einlesen der Bilddaten:
+ *  1. Datei öffnen
+ *  2. Header + Metadaten lesen
+ *  3. Speicher anlegen
+ *  4. Pixeldaten + Labels laden
+ *  5. Datei schließen
+ *  6. Zeiger auf fertige Daten zurückgeben
+ */
+GrayScaleImageSeries *readImages(const char *path)
+{
+    unsigned short count, width, height;
+    GrayScaleImageSeries *series = NULL;
+
+    // Datei im binären Modus öffnen
+    FILE *file = fopen(path, "rb");
+    if (file == NULL)
+    {
+        return NULL;
+    }
+
+    // Header überprüfen und Metadaten lesen
+    if (!checkheader(file, &count, &width, &height))
+    {
+        closefile(file);
+        return NULL;
+    }
+
+    // Speicher für Serie anlegen
+    series = allocateSeries(count, width, height);
+    if (series == NULL)
+    {
+        closefile(file);
+        return NULL;
+    }
+
+    // Bilddaten laden
+    if (!loadImageData(file, series, count, width, height))
+    {
+        clearSeries(series);
+        closefile(file);
+        return NULL;
+    }
+
+    // Datei schließen und fertige Struktur zurückgeben
+    closefile(file);
+
+    return series;
+}
+
+/*
+ * Gibt den gesamten reservierten Speicher der Bildserie wieder frei.
+ * Dazu:
+ *   - alle Pixelpuffer
+ *   - Bilderarray
+ *   - Labelsarray
+ *   - Hauptstruktur
+ */
 void clearSeries(GrayScaleImageSeries *series)
 {
-}
+    if (series != NULL)
+    {
+        // Erst alle Bildpuffer freigeben
+        for (unsigned int i = 0; i < series->count; i++)
+        {
+            free(series->images[i].buffer);
+        }
+
+        // Danach Arrays freigeben
+        free(series->images);
+        free(series->labels);
+
+        // Am Ende die Struktur selbst
+        free(series);
+    }
+
+    // count, width, height müssen nicht auf 0 gesetzt werden,
+    // da sie bei einer Neu-Allokation sowieso überschrieben werden.
+}

imageInputTests.c

@@ -1,12 +1,15 @@
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include "unity.h"
 #include "imageInput.h"
+#define FILE_HEADER_STRING "__info2_image_file_format__"
 
-
+/*
-static void prepareImageFile(const char *path, unsigned short int width, unsigned short int height, unsigned int short numberOfImages, unsigned char label)
+ * Hilfsfunktion, um testweise eine valide .info2-Datei zu erzeugen.
+ * Diese wird von mehreren Tests genutzt.
+ */
+static void prepareImageFile(const char *path, unsigned short int width, unsigned short int height, unsigned short numberOfImages, unsigned char label)
 {
     FILE *file = fopen(path, "wb");
 
@@ -17,7 +20,7 @@ static void prepareImageFile(const char *path, unsigned short int width, unsigne
 
         if(zeroBuffer != NULL)
         {
-            fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
+            fwrite(fileTag, 1, strlen(fileTag), file);
             fwrite(&numberOfImages, sizeof(numberOfImages), 1, file);
             fwrite(&width, sizeof(width), 1, file);
             fwrite(&height, sizeof(height), 1, file);
@@ -36,15 +39,22 @@ static void prepareImageFile(const char *path, unsigned short int width, unsigne
 }
 
 
+/****************************************************
+ *                 Bestehende Tests                 *
+ ****************************************************/
+
 void test_readImagesReturnsCorrectNumberOfImages(void)
 {
     GrayScaleImageSeries *series = NULL;
     const unsigned short expectedNumberOfImages = 2;
     const char *path = "testFile.info2";
+
     prepareImageFile(path, 8, 8, expectedNumberOfImages, 1);
     series = readImages(path);
+
     TEST_ASSERT_NOT_NULL(series);
     TEST_ASSERT_EQUAL_UINT16(expectedNumberOfImages, series->count);
+
     clearSeries(series);
     remove(path);
 }
@@ -54,13 +64,16 @@ void test_readImagesReturnsCorrectImageWidth(void)
     GrayScaleImageSeries *series = NULL;
     const unsigned short expectedWidth = 10;
     const char *path = "testFile.info2";
+
     prepareImageFile(path, expectedWidth, 8, 2, 1);
     series = readImages(path);
+
     TEST_ASSERT_NOT_NULL(series);
     TEST_ASSERT_NOT_NULL(series->images);
     TEST_ASSERT_EQUAL_UINT16(2, series->count);
     TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[0].width);
     TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[1].width);
+
     clearSeries(series);
     remove(path);
 }
@@ -70,13 +83,16 @@ void test_readImagesReturnsCorrectImageHeight(void)
     GrayScaleImageSeries *series = NULL;
     const unsigned short expectedHeight = 10;
     const char *path = "testFile.info2";
+
     prepareImageFile(path, 8, expectedHeight, 2, 1);
     series = readImages(path);
+
     TEST_ASSERT_NOT_NULL(series);
     TEST_ASSERT_NOT_NULL(series->images);
     TEST_ASSERT_EQUAL_UINT16(2, series->count);
     TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[0].height);
     TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[1].height);
+
     clearSeries(series);
     remove(path);
 }
@@ -84,17 +100,21 @@ void test_readImagesReturnsCorrectImageHeight(void)
 void test_readImagesReturnsCorrectLabels(void)
 {
     const unsigned char expectedLabel = 15;
-
     GrayScaleImageSeries *series = NULL;
     const char *path = "testFile.info2";
+
     prepareImageFile(path, 8, 8, 2, expectedLabel);
     series = readImages(path);
+
     TEST_ASSERT_NOT_NULL(series);
     TEST_ASSERT_NOT_NULL(series->labels);
     TEST_ASSERT_EQUAL_UINT16(2, series->count);
-    for (int i = 0; i < 2; i++) {
+
+    for (int i = 0; i < 2; i++)
+    {
         TEST_ASSERT_EQUAL_UINT8(expectedLabel, series->labels[i]);
     }
+
     clearSeries(series);
     remove(path);
 }
@@ -110,28 +130,162 @@ void test_readImagesFailsOnWrongFileTag(void)
 {
     const char *path = "testFile.info2";
     FILE *file = fopen(path, "w");
+
     if(file != NULL)
     {
         fprintf(file, "some_tag                  ");
         fclose(file);
         TEST_ASSERT_NULL(readImages(path));
     }
+
     remove(path);
 }
 
-void setUp(void) {
+
-    // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
+
+/****************************************************
+ *     Neue Tests     *
+ ****************************************************/
+
+/*
+ * Dieser Test prüft, ob readImages() korrekt fehlschlägt,
+ * wenn die Datei zwar den Header-String enthält, aber
+ * NICHT die erforderlichen folgenden Meta-Informationen:
+ *
+ *  - numberOfImages
+ *  - width
+ *  - height
+ *
+ * Der Header allein reicht NICHT aus – daher MUSS readImages()
+ * die Datei als ungültig erkennen und NULL zurückgeben.
+ */
+void test_readImagesFailsOnIncompleteHeader(void)
+{
+    const char *path = "test_incomplete_header.info2";
+
+    FILE *file = fopen(path, "wb");
+
+    /*
+     * Wir schreiben absichtlich NUR den Datei-Header FILE_HEADER_STRING.
+     * Danach müssten aber 3 Werte folgen:
+     *
+     *   unsigned short count
+     *   unsigned short width
+     *   unsigned short height
+     *
+     * Da diese fehlen, wird readImages() beim Lesen feststellen,
+     * dass fread() nicht genug Daten bekommt → Fehler → NULL.
+     */
+    fwrite(FILE_HEADER_STRING, 1, strlen(FILE_HEADER_STRING), file);
+
+    fclose(file);
+
+    TEST_ASSERT_NULL(readImages(path));
+
+    remove(path);
 }
 
-void tearDown(void) {
+
-    // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
+
+/*
+ * Dieser Test erzeugt eine Datei mit
+ *    count = 1
+ *    width = 4
+ *    height = 4
+ *
+ * Daraus folgt:
+ *    1 Bild → 16 Pixelbytes + 1 Labelbyte müssen folgen.
+ *
+ * WIR SCHREIBEN ABER NUR 5 Pixelbytes!
+ *
+ * Das bedeutet:
+ *  - loadImageData() erhält weniger Daten als erwartet
+ *  - fread() liefert eine zu kleine Anzahl gelesener Bytes
+ *  - loadImageData() gibt 0 zurück
+ *  - readImages() erkennt den Fehler und gibt NULL zurück
+ */
+void test_readImagesFailsOnTooFewPixels(void)
+{
+    const char *path = "test_incomplete_pixels.info2";
+    FILE *file = fopen(path, "wb");
+
+    unsigned short count = 1, width = 4, height = 4;
+
+    /* Header + reguläre Metadaten */
+    fwrite(FILE_HEADER_STRING, 1, strlen(FILE_HEADER_STRING), file);
+    fwrite(&count, sizeof(count), 1, file);
+    fwrite(&width, sizeof(width), 1, file);
+    fwrite(&height, sizeof(height), 1, file);
+
+    /*
+     * Erwartet wären 4 × 4 = 16 Pixelbytes.
+     * Wir schreiben ABSICHTLICH NUR 5.
+     */
+    unsigned char pixels[5] = {0};
+    fwrite(pixels, 1, 5, file);
+
+    fclose(file);
+
+    /* Erwartung: Fehler erkannt → NULL */
+    TEST_ASSERT_NULL(readImages(path));
+
+    remove(path);
 }
 
+
+
+/*
+ * Test prüft ungültige Meta-Daten:
+ *
+ * width = 0  → Ein Bild mit Breite 0 existiert nicht.
+ *
+ * Auch height = 0 wäre ungültig.
+ *
+ * readImages() muss solche Fälle erkennen, bevor Speicher
+ * allokiert wird. Sobald width oder height 0 ist, muss
+ * readImages() abbrechen → NULL zurückgeben.
+ */
+void test_readImagesFailsOnZeroWidthOrHeight(void)
+{
+    const char *path = "test_zero_dims.info2";
+    FILE *file = fopen(path, "wb");
+
+    unsigned short count = 1, width = 0, height = 5;
+
+    /* Header + fehlerhafte Metadaten */
+    fwrite(FILE_HEADER_STRING, 1, strlen(FILE_HEADER_STRING), file);
+    fwrite(&count, sizeof(count), 1, file);
+    fwrite(&width, sizeof(width), 1, file);
+    fwrite(&height, sizeof(height), 1, file);
+
+    fclose(file);
+
+    TEST_ASSERT_NULL(readImages(path));
+
+    remove(path);
+}
+
+
+
+/****************************************************
+ *                 Unity Setup/Teardown             *
+ ****************************************************/
+
+void setUp(void)  { /* nicht benötigt */ }
+void tearDown(void) { /* nicht benötigt */ }
+
+
+
+/****************************************************
+ *                      MAIN                        *
+ ****************************************************/
+
 int main()
 {
     UNITY_BEGIN();
-    
+
     printf("\n============================\nImage input tests\n============================\n");
+
     RUN_TEST(test_readImagesReturnsCorrectNumberOfImages);
     RUN_TEST(test_readImagesReturnsCorrectImageWidth);
     RUN_TEST(test_readImagesReturnsCorrectImageHeight);
@@ -139,5 +293,10 @@ int main()
     RUN_TEST(test_readImagesReturnsNullOnNotExistingPath);
     RUN_TEST(test_readImagesFailsOnWrongFileTag);
 
+    /* Neue Tests */
+    RUN_TEST(test_readImagesFailsOnIncompleteHeader);
+    RUN_TEST(test_readImagesFailsOnTooFewPixels);
+    RUN_TEST(test_readImagesFailsOnZeroWidthOrHeight);
+
     return UNITY_END();
-}
+}

matrix.c

@@ -4,32 +4,139 @@
 
 // TODO Matrix-Funktionen implementieren
 
+/*
 Matrix createMatrix(unsigned int rows, unsigned int cols)
 {
-    
+   
+    Matrix result;
+
+    // Sonderfall: ungültige Dimensionen
+    if (rows == 0 || cols == 0)
+    {
+        result.rows = 0;
+        result.cols = 0;
+        result.buffer = NULL;
+        return result;
+    }
+
+    // Speicher für rows * cols Elemente vom Typ MatrixType reservieren
+    result.buffer = malloc(rows * cols * sizeof(MatrixType));
+
+    // Wenn malloc fehlschlägt, Matrix als leer zurückgeben
+    if (result.buffer == NULL)
+    {
+        result.rows = 0;
+        result.cols = 0;
+        return result;
+    }
+
+    // Erfolgreiche Initialisierung
+    result.rows = rows;
+    result.cols = cols;
+    return result;
 }
 
+*/
+
+// Erstellt eine neue Matrix mit gegebener Zeilen- und Spaltenanzahl
+Matrix createMatrix(unsigned int rows, unsigned int cols)
+{
+    Matrix matrix = {NULL,0, 0}; // Initialisierung mit leeren Werten
+    if (rows == 0 || cols == 0) return matrix; // Ungültige Dimensionen → leere Matrix zurückgeben
+
+    matrix.rows = rows;
+    matrix.cols = cols;
+    matrix.buffer = malloc(rows * cols * sizeof(MatrixType)); // Speicher für die Matrixdaten reservieren
+
+    if (matrix.buffer == NULL) { // Falls Speicherreservierung fehlschlägt
+        matrix.rows = 0;
+        matrix.cols = 0;
+    }
+
+    return matrix;
+}
+
+// Gibt den Speicher einer Matrix frei und setzt die Werte auf Null
 void clearMatrix(Matrix *matrix)
 {
-    
+    if (matrix->buffer != NULL) {
+        free(matrix->buffer); // Speicher freigeben
+        matrix->buffer = NULL;
+    }
+    matrix->rows = 0;
+    matrix->cols = 0;
 }
 
+// Setzt einen Wert an eine bestimmte Position in der Matrix
 void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    
+    if (rowIdx >= matrix.rows || colIdx >= matrix.cols || matrix.buffer == NULL) return;
+    matrix.buffer[rowIdx * matrix.cols + colIdx] = value; // Indexberechnung: Zeile * Spaltenanzahl + Spalte
 }
 
+// Gibt den Wert an einer bestimmten Position zurück
 MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    
+    if (rowIdx >= matrix.rows || colIdx >= matrix.cols || matrix.buffer == NULL)
+        return UNDEFINED_MATRIX_VALUE; // Rückgabe eines Standardwerts bei ungültigem Zugriff
+    return matrix.buffer[rowIdx * matrix.cols + colIdx];
 }
 
+// Addiert zwei Matrizen miteinander (entweder elementweise oder mit Broadcasting)
 Matrix add(const Matrix matrix1, const Matrix matrix2)
 {
-    
+    Matrix result = {NULL,0, 0};
+
+    // Elementweise Addition: gleiche Dimensionen
+    if (matrix1.rows == matrix2.rows && matrix1.cols == matrix2.cols) {
+        result = createMatrix(matrix1.rows, matrix1.cols);
+        if (result.buffer == NULL) return result;
+
+        for (unsigned int i = 0; i < matrix1.rows * matrix1.cols; ++i)
+            result.buffer[i] = matrix1.buffer[i] + matrix2.buffer[i];
+
+        return result;
+    }
+
+    // Broadcasting: eine Matrix hat nur eine Spalte (Spaltenvektor)
+    if (matrix1.rows == matrix2.rows && (matrix1.cols == 1 || matrix2.cols == 1)) {
+        Matrix matrix = matrix1.cols == 1 ? matrix1 : matrix2; // Vektor
+        Matrix other = matrix1.cols == 1 ? matrix2 : matrix1;  // Matrix
+
+        result = createMatrix(other.rows, other.cols);
+        if (result.buffer == NULL) return result;
+
+        for (unsigned int r = 0; r < other.rows; ++r) {
+            MatrixType val = matrix.buffer[r]; // Wert aus dem Vektor
+            for (unsigned int c = 0; c < other.cols; ++c)
+                result.buffer[r * other.cols + c] = other.buffer[r * other.cols + c] + val;
+        }
+        return result;
+    }
+
+    return result; // Rückgabe einer leeren Matrix bei inkompatiblen Dimensionen
 }
 
+// Multipliziert zwei Matrizen miteinander (Matrixmultiplikation)
 Matrix multiply(const Matrix matrix1, const Matrix matrix2)
 {
-    
+    Matrix result = {NULL,0, 0};
+
+    if (matrix1.cols != matrix2.rows) return result; // Dimensionen müssen passen: A.cols == B.rows
+
+    result = createMatrix(matrix1.rows, matrix2.cols);
+    if (result.buffer == NULL) return result;
+
+    // Matrixmultiplikation: Zeile von A mit Spalte von B multiplizieren
+    for (unsigned int i = 0; i < matrix1.rows; ++i) {
+        for (unsigned int j = 0; j < matrix2.cols; ++j) {
+            MatrixType sum = 0;
+            for (unsigned int k = 0; k < matrix1.cols; ++k) {
+                sum += getMatrixAt(matrix1, i, k) * getMatrixAt(matrix2, k, j);
+            }
+            setMatrixAt(sum, result, i, j);
+        }
+    }
+
+    return result;
 }

matrix.h

@@ -6,6 +6,14 @@
 typedef float MatrixType;
 
 // TODO Matrixtyp definieren
+// *****************************************************
+typedef struct {
+    MatrixType *buffer;
+    unsigned int rows;
+    unsigned int cols;
+} Matrix;
+// *****************************************************
+
 
 
 Matrix createMatrix(unsigned int rows, unsigned int cols);

neuralNetworkTests.c

@@ -8,7 +8,46 @@
 
 static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
 {
-    // TODO
+    FILE *file = fopen(path, "wb"); //Datei öffnen im write binary modus
+    if (!file) //wenn fopen 0 zurück gibt
+    {
+        fprintf(stderr, "Fehler: Datei konnte nicht geöffnet werden.\n");
+        return;
+    }
+
+    // Header schreiben
+    const char *header = "__info2_neural_network_file_format__";
+    fwrite(header, sizeof(char), strlen(header), file); // Zeiger auf Daten, größe des ElementsChar (1 byte), 
+    //länge des Stings ohen \0, Zieldatei
+
+    // Erste Dimension: Input-Dimension der ersten Schicht (Anzahl der Eingangsneuronen)Anzahl Spalten
+    unsigned int inputDim = nn.layers[0].weights.cols;  
+    // Speichert die Input-Dimension in die Datei
+    fwrite(&inputDim, sizeof(unsigned int), 1, file);
+
+    // Für jede Schicht im Netzwerk
+    for (int i = 0; i < nn.numberOfLayers; i++) 
+    {
+        Layer layer = nn.layers[i];  // Zugriff auf die aktuelle Schicht
+
+        // Output-Dimension: Anzahl der Neuronen in dieser Schicht (Anzahl Zeilen der Gewichtsmatrix) 
+        unsigned int outputDim = layer.weights.rows;
+        // Speichert die Output-Dimension in die Datei
+        fwrite(&outputDim, sizeof(unsigned int), 1, file);
+
+        // Speichert die Gewichtsmatrix der Schicht in die Datei
+        // Anzahl der Elemente = rows * cols, Typ = MatrixType
+        fwrite(layer.weights.buffer, sizeof(MatrixType),
+               layer.weights.rows * layer.weights.cols, file);
+
+        // Speichert die Bias-Werte der Schicht in die Datei
+        // Anzahl der Elemente = rows * cols (meist rows x 1), Typ = MatrixType
+        fwrite(layer.biases.buffer, sizeof(MatrixType),
+               layer.biases.rows * layer.biases.cols, file);
+    }
+
+// Schließt die Datei nach dem Schreiben
+fclose(file);
 }
 
 void test_loadModelReturnsCorrectNumberOfLayers(void)

runImageInputTests.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.runImageInputTests</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

runImageInputTests.dSYM/Contents/Resources/Relocations/x86_64/runImageInputTests.yml

@@ -0,0 +1,113 @@
+---
+triple:          'x86_64-apple-darwin'
+binary-path:     runImageInputTests
+relocations:
+  - { offset: 0x26, size: 0x8, addend: 0x0, symName: _test_readImagesReturnsCorrectNumberOfImages, symObjAddr: 0x0, symBinAddr: 0x100000700, symSize: 0xB0 }
+  - { offset: 0x6E, size: 0x8, addend: 0x0, symName: _test_readImagesReturnsCorrectNumberOfImages, symObjAddr: 0x0, symBinAddr: 0x100000700, symSize: 0xB0 }
+  - { offset: 0xAE, size: 0x8, addend: 0x0, symName: _prepareImageFile, symObjAddr: 0xB0, symBinAddr: 0x1000007B0, symSize: 0x160 }
+  - { offset: 0x15E, size: 0x8, addend: 0x0, symName: _test_readImagesReturnsCorrectImageWidth, symObjAddr: 0x210, symBinAddr: 0x100000910, symSize: 0x130 }
+  - { offset: 0x19E, size: 0x8, addend: 0x0, symName: _test_readImagesReturnsCorrectImageHeight, symObjAddr: 0x340, symBinAddr: 0x100000A40, symSize: 0x130 }
+  - { offset: 0x1DE, size: 0x8, addend: 0x0, symName: _test_readImagesReturnsCorrectLabels, symObjAddr: 0x470, symBinAddr: 0x100000B70, symSize: 0x130 }
+  - { offset: 0x23A, size: 0x8, addend: 0x0, symName: _test_readImagesReturnsNullOnNotExistingPath, symObjAddr: 0x5A0, symBinAddr: 0x100000CA0, symSize: 0x50 }
+  - { offset: 0x25E, size: 0x8, addend: 0x0, symName: _test_readImagesFailsOnWrongFileTag, symObjAddr: 0x5F0, symBinAddr: 0x100000CF0, symSize: 0x90 }
+  - { offset: 0x290, size: 0x8, addend: 0x0, symName: _test_readImagesFailsOnIncompleteHeader, symObjAddr: 0x680, symBinAddr: 0x100000D80, symSize: 0x90 }
+  - { offset: 0x2C2, size: 0x8, addend: 0x0, symName: _test_readImagesFailsOnTooFewPixels, symObjAddr: 0x710, symBinAddr: 0x100000E10, symSize: 0x110 }
+  - { offset: 0x32C, size: 0x8, addend: 0x0, symName: _test_readImagesFailsOnZeroWidthOrHeight, symObjAddr: 0x820, symBinAddr: 0x100000F20, symSize: 0xE0 }
+  - { offset: 0x388, size: 0x8, addend: 0x0, symName: _setUp, symObjAddr: 0x900, symBinAddr: 0x100001000, symSize: 0x10 }
+  - { offset: 0x39E, size: 0x8, addend: 0x0, symName: _tearDown, symObjAddr: 0x910, symBinAddr: 0x100001010, symSize: 0x10 }
+  - { offset: 0x3B4, size: 0x8, addend: 0x0, symName: _main, symObjAddr: 0x920, symBinAddr: 0x100001020, symSize: 0x10C }
+  - { offset: 0x670, size: 0x8, addend: 0x0, symName: _readImages, symObjAddr: 0x0, symBinAddr: 0x100001130, symSize: 0x120 }
+  - { offset: 0x691, size: 0x8, addend: 0x0, symName: _readImages, symObjAddr: 0x0, symBinAddr: 0x100001130, symSize: 0x120 }
+  - { offset: 0x6FF, size: 0x8, addend: 0x0, symName: _checkheader, symObjAddr: 0x120, symBinAddr: 0x100001250, symSize: 0x160 }
+  - { offset: 0x773, size: 0x8, addend: 0x0, symName: _closefile, symObjAddr: 0x280, symBinAddr: 0x1000013B0, symSize: 0x30 }
+  - { offset: 0x797, size: 0x8, addend: 0x0, symName: _allocateSeries, symObjAddr: 0x2B0, symBinAddr: 0x1000013E0, symSize: 0x180 }
+  - { offset: 0x805, size: 0x8, addend: 0x0, symName: _loadImageData, symObjAddr: 0x430, symBinAddr: 0x100001560, symSize: 0xE0 }
+  - { offset: 0x89D, size: 0x8, addend: 0x0, symName: _clearSeries, symObjAddr: 0x510, symBinAddr: 0x100001640, symSize: 0x7D }
+  - { offset: 0xBB7, size: 0x8, addend: 0x0, symName: _UnityPrint, symObjAddr: 0x0, symBinAddr: 0x1000016C0, symSize: 0x60 }
+  - { offset: 0xBD0, size: 0x8, addend: 0x0, symName: _UnityStrOk, symObjAddr: 0x4390, symBinAddr: 0x100005CD0, symSize: 0x0 }
+  - { offset: 0xC04, size: 0x8, addend: 0x0, symName: _UnityStrPass, symObjAddr: 0x4393, symBinAddr: 0x100005CD3, symSize: 0x0 }
+  - { offset: 0xC25, size: 0x8, addend: 0x0, symName: _UnityStrFail, symObjAddr: 0x4398, symBinAddr: 0x100005CD8, symSize: 0x0 }
+  - { offset: 0xC3A, size: 0x8, addend: 0x0, symName: _UnityStrIgnore, symObjAddr: 0x439D, symBinAddr: 0x100005CDD, symSize: 0x0 }
+  - { offset: 0xC5B, size: 0x8, addend: 0x0, symName: _UnityStrErrShorthand, symObjAddr: 0x43B0, symBinAddr: 0x100005CF0, symSize: 0x0 }
+  - { offset: 0xC7C, size: 0x8, addend: 0x0, symName: _UnityStrErrFloat, symObjAddr: 0x43E0, symBinAddr: 0x100005D20, symSize: 0x0 }
+  - { offset: 0xC9D, size: 0x8, addend: 0x0, symName: _UnityStrErrDouble, symObjAddr: 0x4400, symBinAddr: 0x100005D40, symSize: 0x0 }
+  - { offset: 0xCBE, size: 0x8, addend: 0x0, symName: _UnityStrErr64, symObjAddr: 0x4420, symBinAddr: 0x100005D60, symSize: 0x0 }
+  - { offset: 0xCD3, size: 0x8, addend: 0x0, symName: _UnityStrErrDetailStack, symObjAddr: 0x4440, symBinAddr: 0x100005D80, symSize: 0x0 }
+  - { offset: 0xCE8, size: 0x8, addend: 0x0, symName: _UnityPrintFloat, symObjAddr: 0x5D0, symBinAddr: 0x100001C90, symSize: 0x6D0 }
+  - { offset: 0xD0B, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.sig_digits, symObjAddr: 0x4464, symBinAddr: 0x100005DA4, symSize: 0x0 }
+  - { offset: 0xD21, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.min_scaled, symObjAddr: 0x4468, symBinAddr: 0x100005DA8, symSize: 0x0 }
+  - { offset: 0xD37, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.max_scaled, symObjAddr: 0x446C, symBinAddr: 0x100005DAC, symSize: 0x0 }
+  - { offset: 0xF07, size: 0x8, addend: 0x0, symName: _Unity, symBinAddr: 0x100007008, symSize: 0x0 }
+  - { offset: 0xFEF, size: 0x8, addend: 0x0, symName: _UnityQuickCompare, symObjAddr: 0xAE68, symBinAddr: 0x100007000, symSize: 0x0 }
+  - { offset: 0x1088, size: 0x8, addend: 0x0, symName: _UnityStrExpected, symObjAddr: 0x4470, symBinAddr: 0x100005DB0, symSize: 0x0 }
+  - { offset: 0x10A9, size: 0x8, addend: 0x0, symName: _UnityStrWas, symObjAddr: 0x447B, symBinAddr: 0x100005DBB, symSize: 0x0 }
+  - { offset: 0x10CA, size: 0x8, addend: 0x0, symName: _UnityStrSpacer, symObjAddr: 0x4605, symBinAddr: 0x100005F45, symSize: 0x0 }
+  - { offset: 0x10DF, size: 0x8, addend: 0x0, symName: _UnityStrDetail1Name, symObjAddr: 0x4608, symBinAddr: 0x100005F48, symSize: 0x0 }
+  - { offset: 0x1100, size: 0x8, addend: 0x0, symName: _UnityStrDetail2Name, symObjAddr: 0x4612, symBinAddr: 0x100005F52, symSize: 0x0 }
+  - { offset: 0x1115, size: 0x8, addend: 0x0, symName: _UnityStrGt, symObjAddr: 0x4490, symBinAddr: 0x100005DD0, symSize: 0x0 }
+  - { offset: 0x1136, size: 0x8, addend: 0x0, symName: _UnityStrLt, symObjAddr: 0x44B0, symBinAddr: 0x100005DF0, symSize: 0x0 }
+  - { offset: 0x1157, size: 0x8, addend: 0x0, symName: _UnityStrOrEqual, symObjAddr: 0x44C2, symBinAddr: 0x100005E02, symSize: 0x0 }
+  - { offset: 0x1178, size: 0x8, addend: 0x0, symName: _UnityStrNotEqual, symObjAddr: 0x44D0, symBinAddr: 0x100005E10, symSize: 0x0 }
+  - { offset: 0x118D, size: 0x8, addend: 0x0, symName: _UnityStrPointless, symObjAddr: 0x44F0, symBinAddr: 0x100005E30, symSize: 0x0 }
+  - { offset: 0x11AE, size: 0x8, addend: 0x0, symName: _UnityStrNullPointerForExpected, symObjAddr: 0x4620, symBinAddr: 0x100005F60, symSize: 0x0 }
+  - { offset: 0x11CF, size: 0x8, addend: 0x0, symName: _UnityStrNullPointerForActual, symObjAddr: 0x4640, symBinAddr: 0x100005F80, symSize: 0x0 }
+  - { offset: 0x11F0, size: 0x8, addend: 0x0, symName: _UnityStrElement, symObjAddr: 0x4527, symBinAddr: 0x100005E67, symSize: 0x0 }
+  - { offset: 0x1205, size: 0x8, addend: 0x0, symName: _UnityStrInf, symObjAddr: 0x4531, symBinAddr: 0x100005E71, symSize: 0x0 }
+  - { offset: 0x1226, size: 0x8, addend: 0x0, symName: _UnityStrNegInf, symObjAddr: 0x4540, symBinAddr: 0x100005E80, symSize: 0x0 }
+  - { offset: 0x123B, size: 0x8, addend: 0x0, symName: _UnityStrNaN, symObjAddr: 0x4552, symBinAddr: 0x100005E92, symSize: 0x0 }
+  - { offset: 0x125C, size: 0x8, addend: 0x0, symName: _UnityStrDet, symObjAddr: 0x4556, symBinAddr: 0x100005E96, symSize: 0x0 }
+  - { offset: 0x127D, size: 0x8, addend: 0x0, symName: _UnityStrInvalidFloatTrait, symObjAddr: 0x4570, symBinAddr: 0x100005EB0, symSize: 0x0 }
+  - { offset: 0x129E, size: 0x8, addend: 0x0, symName: _UnityStrNot, symObjAddr: 0x4584, symBinAddr: 0x100005EC4, symSize: 0x0 }
+  - { offset: 0x12B3, size: 0x8, addend: 0x0, symName: _UnityStrDelta, symObjAddr: 0x4590, symBinAddr: 0x100005ED0, symSize: 0x0 }
+  - { offset: 0x12D4, size: 0x8, addend: 0x0, symName: _UnityStrNull, symObjAddr: 0x4659, symBinAddr: 0x100005F99, symSize: 0x0 }
+  - { offset: 0x12E9, size: 0x8, addend: 0x0, symName: _UnityStrMemory, symObjAddr: 0x45B0, symBinAddr: 0x100005EF0, symSize: 0x0 }
+  - { offset: 0x12FE, size: 0x8, addend: 0x0, symName: _UnityStrByte, symObjAddr: 0x45C2, symBinAddr: 0x100005F02, symSize: 0x0 }
+  - { offset: 0x1313, size: 0x8, addend: 0x0, symName: _UnityStrBreaker, symObjAddr: 0x45D0, symBinAddr: 0x100005F10, symSize: 0x0 }
+  - { offset: 0x1334, size: 0x8, addend: 0x0, symName: _UnityStrResultsTests, symObjAddr: 0x45E8, symBinAddr: 0x100005F28, symSize: 0x0 }
+  - { offset: 0x1355, size: 0x8, addend: 0x0, symName: _UnityStrResultsFailures, symObjAddr: 0x45F0, symBinAddr: 0x100005F30, symSize: 0x0 }
+  - { offset: 0x136A, size: 0x8, addend: 0x0, symName: _UnityStrResultsIgnored, symObjAddr: 0x45FB, symBinAddr: 0x100005F3B, symSize: 0x0 }
+  - { offset: 0x14E3, size: 0x8, addend: 0x0, symName: _UnityPrint, symObjAddr: 0x0, symBinAddr: 0x1000016C0, symSize: 0x60 }
+  - { offset: 0x1515, size: 0x8, addend: 0x0, symName: _UnityPrintChar, symObjAddr: 0x60, symBinAddr: 0x100001720, symSize: 0xD0 }
+  - { offset: 0x1539, size: 0x8, addend: 0x0, symName: _UnityPrintLen, symObjAddr: 0x130, symBinAddr: 0x1000017F0, symSize: 0x130 }
+  - { offset: 0x1579, size: 0x8, addend: 0x0, symName: _UnityPrintNumberHex, symObjAddr: 0x260, symBinAddr: 0x100001920, symSize: 0x90 }
+  - { offset: 0x15CC, size: 0x8, addend: 0x0, symName: _UnityPrintIntNumberByStyle, symObjAddr: 0x2F0, symBinAddr: 0x1000019B0, symSize: 0x100 }
+  - { offset: 0x15FE, size: 0x8, addend: 0x0, symName: _UnityPrintNumber, symObjAddr: 0x3F0, symBinAddr: 0x100001AB0, symSize: 0x50 }
+  - { offset: 0x1630, size: 0x8, addend: 0x0, symName: _UnityPrintUintNumberByStyle, symObjAddr: 0x440, symBinAddr: 0x100001B00, symSize: 0x60 }
+  - { offset: 0x1662, size: 0x8, addend: 0x0, symName: _UnityPrintNumberUnsigned, symObjAddr: 0x4A0, symBinAddr: 0x100001B60, symSize: 0x90 }
+  - { offset: 0x1697, size: 0x8, addend: 0x0, symName: _UnityPrintMask, symObjAddr: 0x530, symBinAddr: 0x100001BF0, symSize: 0xA0 }
+  - { offset: 0x177A, size: 0x8, addend: 0x0, symName: _UnityConcludeTest, symObjAddr: 0xCA0, symBinAddr: 0x100002360, symSize: 0xC0 }
+  - { offset: 0x1790, size: 0x8, addend: 0x0, symName: _UnityTestResultsBegin, symObjAddr: 0xD60, symBinAddr: 0x100002420, symSize: 0x60 }
+  - { offset: 0x17C5, size: 0x8, addend: 0x0, symName: _UnityAssertBits, symObjAddr: 0xDC0, symBinAddr: 0x100002480, symSize: 0xE0 }
+  - { offset: 0x1827, size: 0x8, addend: 0x0, symName: _UnityTestResultsFailBegin, symObjAddr: 0xEA0, symBinAddr: 0x100002560, symSize: 0x40 }
+  - { offset: 0x184D, size: 0x8, addend: 0x0, symName: _UnityAddMsgIfSpecified, symObjAddr: 0xEE0, symBinAddr: 0x1000025A0, symSize: 0xA0 }
+  - { offset: 0x1873, size: 0x8, addend: 0x0, symName: _UnityAssertEqualIntNumber, symObjAddr: 0xF80, symBinAddr: 0x100002640, symSize: 0xD0 }
+  - { offset: 0x18D5, size: 0x8, addend: 0x0, symName: _UnityAssertEqualUintNumber, symObjAddr: 0x1050, symBinAddr: 0x100002710, symSize: 0xD0 }
+  - { offset: 0x1937, size: 0x8, addend: 0x0, symName: _UnityAssertIntGreaterOrLessOrEqualNumber, symObjAddr: 0x1120, symBinAddr: 0x1000027E0, symSize: 0x1A0 }
+  - { offset: 0x19B7, size: 0x8, addend: 0x0, symName: _UnityAssertUintGreaterOrLessOrEqualNumber, symObjAddr: 0x12C0, symBinAddr: 0x100002980, symSize: 0x1A0 }
+  - { offset: 0x1A37, size: 0x8, addend: 0x0, symName: _UnityAssertEqualIntArray, symObjAddr: 0x1460, symBinAddr: 0x100002B20, symSize: 0x3C0 }
+  - { offset: 0x1B2F, size: 0x8, addend: 0x0, symName: _UnityIsOneArrayNull, symObjAddr: 0x1820, symBinAddr: 0x100002EE0, symSize: 0xB0 }
+  - { offset: 0x1B86, size: 0x8, addend: 0x0, symName: _UnityAssertWithinFloatArray, symObjAddr: 0x18D0, symBinAddr: 0x100002F90, symSize: 0x460 }
+  - { offset: 0x1D10, size: 0x8, addend: 0x0, symName: _UnityFloatsWithin, symObjAddr: 0x1D30, symBinAddr: 0x1000033F0, symSize: 0x5F0 }
+  - { offset: 0x1F94, size: 0x8, addend: 0x0, symName: _UnityAssertFloatsWithin, symObjAddr: 0x2320, symBinAddr: 0x1000039E0, symSize: 0xE0 }
+  - { offset: 0x1FF6, size: 0x8, addend: 0x0, symName: _UnityAssertFloatsNotWithin, symObjAddr: 0x2400, symBinAddr: 0x100003AC0, symSize: 0xE0 }
+  - { offset: 0x2058, size: 0x8, addend: 0x0, symName: _UnityAssertGreaterOrLessFloat, symObjAddr: 0x24E0, symBinAddr: 0x100003BA0, symSize: 0x1A0 }
+  - { offset: 0x20C9, size: 0x8, addend: 0x0, symName: _UnityAssertFloatSpecial, symObjAddr: 0x2680, symBinAddr: 0x100003D40, symSize: 0x600 }
+  - { offset: 0x22B3, size: 0x8, addend: 0x0, symName: _UnityAssertIntNumbersWithin, symObjAddr: 0x2C80, symBinAddr: 0x100004340, symSize: 0x150 }
+  - { offset: 0x2324, size: 0x8, addend: 0x0, symName: _UnityAssertUintNumbersWithin, symObjAddr: 0x2DD0, symBinAddr: 0x100004490, symSize: 0x150 }
+  - { offset: 0x2395, size: 0x8, addend: 0x0, symName: _UnityAssertNumbersArrayWithin, symObjAddr: 0x2F20, symBinAddr: 0x1000045E0, symSize: 0x4E0 }
+  - { offset: 0x249D, size: 0x8, addend: 0x0, symName: _UnityAssertEqualString, symObjAddr: 0x3400, symBinAddr: 0x100004AC0, symSize: 0x180 }
+  - { offset: 0x24FF, size: 0x8, addend: 0x0, symName: _UnityPrintExpectedAndActualStrings, symObjAddr: 0x3580, symBinAddr: 0x100004C40, symSize: 0xA0 }
+  - { offset: 0x2534, size: 0x8, addend: 0x0, symName: _UnityAssertEqualStringLen, symObjAddr: 0x3620, symBinAddr: 0x100004CE0, symSize: 0x1A0 }
+  - { offset: 0x25A5, size: 0x8, addend: 0x0, symName: _UnityPrintExpectedAndActualStringsLen, symObjAddr: 0x37C0, symBinAddr: 0x100004E80, symSize: 0xB0 }
+  - { offset: 0x25E9, size: 0x8, addend: 0x0, symName: _UnityAssertEqualStringArray, symObjAddr: 0x3870, symBinAddr: 0x100004F30, symSize: 0x2B0 }
+  - { offset: 0x2697, size: 0x8, addend: 0x0, symName: _UnityAssertEqualMemory, symObjAddr: 0x3B20, symBinAddr: 0x1000051E0, symSize: 0x2A0 }
+  - { offset: 0x2753, size: 0x8, addend: 0x0, symName: _UnityNumToPtr, symObjAddr: 0x3DC0, symBinAddr: 0x100005480, symSize: 0xB0 }
+  - { offset: 0x278C, size: 0x8, addend: 0x0, symName: _UnityFloatToPtr, symObjAddr: 0x3E70, symBinAddr: 0x100005530, symSize: 0x20 }
+  - { offset: 0x27B6, size: 0x8, addend: 0x0, symName: _UnityFail, symObjAddr: 0x3E90, symBinAddr: 0x100005550, symSize: 0xA0 }
+  - { offset: 0x27EB, size: 0x8, addend: 0x0, symName: _UnityIgnore, symObjAddr: 0x3F30, symBinAddr: 0x1000055F0, symSize: 0xC0 }
+  - { offset: 0x2820, size: 0x8, addend: 0x0, symName: _UnityMessage, symObjAddr: 0x3FF0, symBinAddr: 0x1000056B0, symSize: 0x70 }
+  - { offset: 0x2855, size: 0x8, addend: 0x0, symName: _UnityDefaultTestRun, symObjAddr: 0x4060, symBinAddr: 0x100005720, symSize: 0xD0 }
+  - { offset: 0x2899, size: 0x8, addend: 0x0, symName: _UnitySetTestFile, symObjAddr: 0x4130, symBinAddr: 0x1000057F0, symSize: 0x20 }
+  - { offset: 0x28BF, size: 0x8, addend: 0x0, symName: _UnityBegin, symObjAddr: 0x4150, symBinAddr: 0x100005810, symSize: 0xA0 }
+  - { offset: 0x28E5, size: 0x8, addend: 0x0, symName: _UnityEnd, symObjAddr: 0x41F0, symBinAddr: 0x1000058B0, symSize: 0xC8 }
+...

runMatrixTests.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.runMatrixTests</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

runMatrixTests.dSYM/Contents/Resources/Relocations/x86_64/runMatrixTests.yml

@@ -0,0 +1,115 @@
+---
+triple:          'x86_64-apple-darwin'
+binary-path:     runMatrixTests
+relocations:
+  - { offset: 0x26, size: 0x8, addend: 0x0, symName: _test_createMatrixFailsOnZeroDimensions, symObjAddr: 0x0, symBinAddr: 0x100001130, symSize: 0x100 }
+  - { offset: 0x5D, size: 0x8, addend: 0x0, symName: _test_createMatrixFailsOnZeroDimensions, symObjAddr: 0x0, symBinAddr: 0x100001130, symSize: 0x100 }
+  - { offset: 0x8F, size: 0x8, addend: 0x0, symName: _test_createMatrixReturnsCorrectMatrixDimensions, symObjAddr: 0x100, symBinAddr: 0x100001230, symSize: 0x80 }
+  - { offset: 0xCF, size: 0x8, addend: 0x0, symName: _test_clearMatrixSetsMembersToNull, symObjAddr: 0x180, symBinAddr: 0x1000012B0, symSize: 0x90 }
+  - { offset: 0xF3, size: 0x8, addend: 0x0, symName: _test_addReturnsCorrectResult, symObjAddr: 0x210, symBinAddr: 0x100001340, symSize: 0x1E0 }
+  - { offset: 0x161, size: 0x8, addend: 0x0, symName: _test_addFailsOnDifferentInputDimensions, symObjAddr: 0x3F0, symBinAddr: 0x100001520, symSize: 0x140 }
+  - { offset: 0x1C0, size: 0x8, addend: 0x0, symName: _test_addSupportsBroadcasting, symObjAddr: 0x530, symBinAddr: 0x100001660, symSize: 0x220 }
+  - { offset: 0x23C, size: 0x8, addend: 0x0, symName: _test_multiplyReturnsCorrectResults, symObjAddr: 0x750, symBinAddr: 0x100001880, symSize: 0x1B0 }
+  - { offset: 0x2AB, size: 0x8, addend: 0x0, symName: _test_multiplyFailsOnWrongInputDimensions, symObjAddr: 0x900, symBinAddr: 0x100001A30, symSize: 0x140 }
+  - { offset: 0x30A, size: 0x8, addend: 0x0, symName: _test_getMatrixAtReturnsCorrectResult, symObjAddr: 0xA40, symBinAddr: 0x100001B70, symSize: 0xB0 }
+  - { offset: 0x34A, size: 0x8, addend: 0x0, symName: _test_getMatrixAtFailsOnIndicesOutOfRange, symObjAddr: 0xAF0, symBinAddr: 0x100001C20, symSize: 0xA0 }
+  - { offset: 0x37C, size: 0x8, addend: 0x0, symName: _test_setMatrixAtSetsCorrectValue, symObjAddr: 0xB90, symBinAddr: 0x100001CC0, symSize: 0xC0 }
+  - { offset: 0x3BC, size: 0x8, addend: 0x0, symName: _test_setMatrixAtFailsOnIndicesOutOfRange, symObjAddr: 0xC50, symBinAddr: 0x100001D80, symSize: 0xC0 }
+  - { offset: 0x3FE, size: 0x8, addend: 0x0, symName: _setUp, symObjAddr: 0xD10, symBinAddr: 0x100001E40, symSize: 0x10 }
+  - { offset: 0x413, size: 0x8, addend: 0x0, symName: _tearDown, symObjAddr: 0xD20, symBinAddr: 0x100001E50, symSize: 0x10 }
+  - { offset: 0x428, size: 0x8, addend: 0x0, symName: _main, symObjAddr: 0xD30, symBinAddr: 0x100001E60, symSize: 0x154 }
+  - { offset: 0x515, size: 0x8, addend: 0x0, symName: _createMatrix, symObjAddr: 0x0, symBinAddr: 0x100001FC0, symSize: 0x90 }
+  - { offset: 0x522, size: 0x8, addend: 0x0, symName: _createMatrix, symObjAddr: 0x0, symBinAddr: 0x100001FC0, symSize: 0x90 }
+  - { offset: 0x566, size: 0x8, addend: 0x0, symName: _clearMatrix, symObjAddr: 0x90, symBinAddr: 0x100002050, symSize: 0x50 }
+  - { offset: 0x58A, size: 0x8, addend: 0x0, symName: _setMatrixAt, symObjAddr: 0xE0, symBinAddr: 0x1000020A0, symSize: 0x60 }
+  - { offset: 0x5D8, size: 0x8, addend: 0x0, symName: _getMatrixAt, symObjAddr: 0x140, symBinAddr: 0x100002100, symSize: 0x70 }
+  - { offset: 0x61C, size: 0x8, addend: 0x0, symName: _add, symObjAddr: 0x1B0, symBinAddr: 0x100002170, symSize: 0x230 }
+  - { offset: 0x700, size: 0x8, addend: 0x0, symName: _multiply, symObjAddr: 0x3E0, symBinAddr: 0x1000023A0, symSize: 0x14C }
+  - { offset: 0x83A, size: 0x8, addend: 0x0, symName: _UnityPrint, symObjAddr: 0x0, symBinAddr: 0x1000024F0, symSize: 0x60 }
+  - { offset: 0x853, size: 0x8, addend: 0x0, symName: _UnityStrOk, symObjAddr: 0x4390, symBinAddr: 0x100006AA0, symSize: 0x0 }
+  - { offset: 0x887, size: 0x8, addend: 0x0, symName: _UnityStrPass, symObjAddr: 0x4393, symBinAddr: 0x100006AA3, symSize: 0x0 }
+  - { offset: 0x8A8, size: 0x8, addend: 0x0, symName: _UnityStrFail, symObjAddr: 0x4398, symBinAddr: 0x100006AA8, symSize: 0x0 }
+  - { offset: 0x8BD, size: 0x8, addend: 0x0, symName: _UnityStrIgnore, symObjAddr: 0x439D, symBinAddr: 0x100006AAD, symSize: 0x0 }
+  - { offset: 0x8DE, size: 0x8, addend: 0x0, symName: _UnityStrErrShorthand, symObjAddr: 0x43B0, symBinAddr: 0x100006AC0, symSize: 0x0 }
+  - { offset: 0x8FF, size: 0x8, addend: 0x0, symName: _UnityStrErrFloat, symObjAddr: 0x43E0, symBinAddr: 0x100006AF0, symSize: 0x0 }
+  - { offset: 0x920, size: 0x8, addend: 0x0, symName: _UnityStrErrDouble, symObjAddr: 0x4400, symBinAddr: 0x100006B10, symSize: 0x0 }
+  - { offset: 0x941, size: 0x8, addend: 0x0, symName: _UnityStrErr64, symObjAddr: 0x4420, symBinAddr: 0x100006B30, symSize: 0x0 }
+  - { offset: 0x956, size: 0x8, addend: 0x0, symName: _UnityStrErrDetailStack, symObjAddr: 0x4440, symBinAddr: 0x100006B50, symSize: 0x0 }
+  - { offset: 0x96B, size: 0x8, addend: 0x0, symName: _UnityPrintFloat, symObjAddr: 0x5D0, symBinAddr: 0x100002AC0, symSize: 0x6D0 }
+  - { offset: 0x98E, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.sig_digits, symObjAddr: 0x4464, symBinAddr: 0x100006B74, symSize: 0x0 }
+  - { offset: 0x9A4, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.min_scaled, symObjAddr: 0x4468, symBinAddr: 0x100006B78, symSize: 0x0 }
+  - { offset: 0x9BA, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.max_scaled, symObjAddr: 0x446C, symBinAddr: 0x100006B7C, symSize: 0x0 }
+  - { offset: 0xB8A, size: 0x8, addend: 0x0, symName: _Unity, symBinAddr: 0x100008008, symSize: 0x0 }
+  - { offset: 0xC72, size: 0x8, addend: 0x0, symName: _UnityQuickCompare, symObjAddr: 0xAE68, symBinAddr: 0x100008000, symSize: 0x0 }
+  - { offset: 0xD0B, size: 0x8, addend: 0x0, symName: _UnityStrExpected, symObjAddr: 0x4470, symBinAddr: 0x100006B80, symSize: 0x0 }
+  - { offset: 0xD2C, size: 0x8, addend: 0x0, symName: _UnityStrWas, symObjAddr: 0x447B, symBinAddr: 0x100006B8B, symSize: 0x0 }
+  - { offset: 0xD4D, size: 0x8, addend: 0x0, symName: _UnityStrSpacer, symObjAddr: 0x4605, symBinAddr: 0x100006D15, symSize: 0x0 }
+  - { offset: 0xD62, size: 0x8, addend: 0x0, symName: _UnityStrDetail1Name, symObjAddr: 0x4608, symBinAddr: 0x100006D18, symSize: 0x0 }
+  - { offset: 0xD83, size: 0x8, addend: 0x0, symName: _UnityStrDetail2Name, symObjAddr: 0x4612, symBinAddr: 0x100006D22, symSize: 0x0 }
+  - { offset: 0xD98, size: 0x8, addend: 0x0, symName: _UnityStrGt, symObjAddr: 0x4490, symBinAddr: 0x100006BA0, symSize: 0x0 }
+  - { offset: 0xDB9, size: 0x8, addend: 0x0, symName: _UnityStrLt, symObjAddr: 0x44B0, symBinAddr: 0x100006BC0, symSize: 0x0 }
+  - { offset: 0xDDA, size: 0x8, addend: 0x0, symName: _UnityStrOrEqual, symObjAddr: 0x44C2, symBinAddr: 0x100006BD2, symSize: 0x0 }
+  - { offset: 0xDFB, size: 0x8, addend: 0x0, symName: _UnityStrNotEqual, symObjAddr: 0x44D0, symBinAddr: 0x100006BE0, symSize: 0x0 }
+  - { offset: 0xE10, size: 0x8, addend: 0x0, symName: _UnityStrPointless, symObjAddr: 0x44F0, symBinAddr: 0x100006C00, symSize: 0x0 }
+  - { offset: 0xE31, size: 0x8, addend: 0x0, symName: _UnityStrNullPointerForExpected, symObjAddr: 0x4620, symBinAddr: 0x100006D30, symSize: 0x0 }
+  - { offset: 0xE52, size: 0x8, addend: 0x0, symName: _UnityStrNullPointerForActual, symObjAddr: 0x4640, symBinAddr: 0x100006D50, symSize: 0x0 }
+  - { offset: 0xE73, size: 0x8, addend: 0x0, symName: _UnityStrElement, symObjAddr: 0x4527, symBinAddr: 0x100006C37, symSize: 0x0 }
+  - { offset: 0xE88, size: 0x8, addend: 0x0, symName: _UnityStrInf, symObjAddr: 0x4531, symBinAddr: 0x100006C41, symSize: 0x0 }
+  - { offset: 0xEA9, size: 0x8, addend: 0x0, symName: _UnityStrNegInf, symObjAddr: 0x4540, symBinAddr: 0x100006C50, symSize: 0x0 }
+  - { offset: 0xEBE, size: 0x8, addend: 0x0, symName: _UnityStrNaN, symObjAddr: 0x4552, symBinAddr: 0x100006C62, symSize: 0x0 }
+  - { offset: 0xEDF, size: 0x8, addend: 0x0, symName: _UnityStrDet, symObjAddr: 0x4556, symBinAddr: 0x100006C66, symSize: 0x0 }
+  - { offset: 0xF00, size: 0x8, addend: 0x0, symName: _UnityStrInvalidFloatTrait, symObjAddr: 0x4570, symBinAddr: 0x100006C80, symSize: 0x0 }
+  - { offset: 0xF21, size: 0x8, addend: 0x0, symName: _UnityStrNot, symObjAddr: 0x4584, symBinAddr: 0x100006C94, symSize: 0x0 }
+  - { offset: 0xF36, size: 0x8, addend: 0x0, symName: _UnityStrDelta, symObjAddr: 0x4590, symBinAddr: 0x100006CA0, symSize: 0x0 }
+  - { offset: 0xF57, size: 0x8, addend: 0x0, symName: _UnityStrNull, symObjAddr: 0x4659, symBinAddr: 0x100006D69, symSize: 0x0 }
+  - { offset: 0xF6C, size: 0x8, addend: 0x0, symName: _UnityStrMemory, symObjAddr: 0x45B0, symBinAddr: 0x100006CC0, symSize: 0x0 }
+  - { offset: 0xF81, size: 0x8, addend: 0x0, symName: _UnityStrByte, symObjAddr: 0x45C2, symBinAddr: 0x100006CD2, symSize: 0x0 }
+  - { offset: 0xF96, size: 0x8, addend: 0x0, symName: _UnityStrBreaker, symObjAddr: 0x45D0, symBinAddr: 0x100006CE0, symSize: 0x0 }
+  - { offset: 0xFB7, size: 0x8, addend: 0x0, symName: _UnityStrResultsTests, symObjAddr: 0x45E8, symBinAddr: 0x100006CF8, symSize: 0x0 }
+  - { offset: 0xFD8, size: 0x8, addend: 0x0, symName: _UnityStrResultsFailures, symObjAddr: 0x45F0, symBinAddr: 0x100006D00, symSize: 0x0 }
+  - { offset: 0xFED, size: 0x8, addend: 0x0, symName: _UnityStrResultsIgnored, symObjAddr: 0x45FB, symBinAddr: 0x100006D0B, symSize: 0x0 }
+  - { offset: 0x1166, size: 0x8, addend: 0x0, symName: _UnityPrint, symObjAddr: 0x0, symBinAddr: 0x1000024F0, symSize: 0x60 }
+  - { offset: 0x1198, size: 0x8, addend: 0x0, symName: _UnityPrintChar, symObjAddr: 0x60, symBinAddr: 0x100002550, symSize: 0xD0 }
+  - { offset: 0x11BC, size: 0x8, addend: 0x0, symName: _UnityPrintLen, symObjAddr: 0x130, symBinAddr: 0x100002620, symSize: 0x130 }
+  - { offset: 0x11FC, size: 0x8, addend: 0x0, symName: _UnityPrintNumberHex, symObjAddr: 0x260, symBinAddr: 0x100002750, symSize: 0x90 }
+  - { offset: 0x124F, size: 0x8, addend: 0x0, symName: _UnityPrintIntNumberByStyle, symObjAddr: 0x2F0, symBinAddr: 0x1000027E0, symSize: 0x100 }
+  - { offset: 0x1281, size: 0x8, addend: 0x0, symName: _UnityPrintNumber, symObjAddr: 0x3F0, symBinAddr: 0x1000028E0, symSize: 0x50 }
+  - { offset: 0x12B3, size: 0x8, addend: 0x0, symName: _UnityPrintUintNumberByStyle, symObjAddr: 0x440, symBinAddr: 0x100002930, symSize: 0x60 }
+  - { offset: 0x12E5, size: 0x8, addend: 0x0, symName: _UnityPrintNumberUnsigned, symObjAddr: 0x4A0, symBinAddr: 0x100002990, symSize: 0x90 }
+  - { offset: 0x131A, size: 0x8, addend: 0x0, symName: _UnityPrintMask, symObjAddr: 0x530, symBinAddr: 0x100002A20, symSize: 0xA0 }
+  - { offset: 0x13FD, size: 0x8, addend: 0x0, symName: _UnityConcludeTest, symObjAddr: 0xCA0, symBinAddr: 0x100003190, symSize: 0xC0 }
+  - { offset: 0x1413, size: 0x8, addend: 0x0, symName: _UnityTestResultsBegin, symObjAddr: 0xD60, symBinAddr: 0x100003250, symSize: 0x60 }
+  - { offset: 0x1448, size: 0x8, addend: 0x0, symName: _UnityAssertBits, symObjAddr: 0xDC0, symBinAddr: 0x1000032B0, symSize: 0xE0 }
+  - { offset: 0x14AA, size: 0x8, addend: 0x0, symName: _UnityTestResultsFailBegin, symObjAddr: 0xEA0, symBinAddr: 0x100003390, symSize: 0x40 }
+  - { offset: 0x14D0, size: 0x8, addend: 0x0, symName: _UnityAddMsgIfSpecified, symObjAddr: 0xEE0, symBinAddr: 0x1000033D0, symSize: 0xA0 }
+  - { offset: 0x14F6, size: 0x8, addend: 0x0, symName: _UnityAssertEqualIntNumber, symObjAddr: 0xF80, symBinAddr: 0x100003470, symSize: 0xD0 }
+  - { offset: 0x1558, size: 0x8, addend: 0x0, symName: _UnityAssertEqualUintNumber, symObjAddr: 0x1050, symBinAddr: 0x100003540, symSize: 0xD0 }
+  - { offset: 0x15BA, size: 0x8, addend: 0x0, symName: _UnityAssertIntGreaterOrLessOrEqualNumber, symObjAddr: 0x1120, symBinAddr: 0x100003610, symSize: 0x1A0 }
+  - { offset: 0x163A, size: 0x8, addend: 0x0, symName: _UnityAssertUintGreaterOrLessOrEqualNumber, symObjAddr: 0x12C0, symBinAddr: 0x1000037B0, symSize: 0x1A0 }
+  - { offset: 0x16BA, size: 0x8, addend: 0x0, symName: _UnityAssertEqualIntArray, symObjAddr: 0x1460, symBinAddr: 0x100003950, symSize: 0x3C0 }
+  - { offset: 0x17B2, size: 0x8, addend: 0x0, symName: _UnityIsOneArrayNull, symObjAddr: 0x1820, symBinAddr: 0x100003D10, symSize: 0xB0 }
+  - { offset: 0x1809, size: 0x8, addend: 0x0, symName: _UnityAssertWithinFloatArray, symObjAddr: 0x18D0, symBinAddr: 0x100003DC0, symSize: 0x460 }
+  - { offset: 0x1993, size: 0x8, addend: 0x0, symName: _UnityFloatsWithin, symObjAddr: 0x1D30, symBinAddr: 0x100004220, symSize: 0x5F0 }
+  - { offset: 0x1C17, size: 0x8, addend: 0x0, symName: _UnityAssertFloatsWithin, symObjAddr: 0x2320, symBinAddr: 0x100004810, symSize: 0xE0 }
+  - { offset: 0x1C79, size: 0x8, addend: 0x0, symName: _UnityAssertFloatsNotWithin, symObjAddr: 0x2400, symBinAddr: 0x1000048F0, symSize: 0xE0 }
+  - { offset: 0x1CDB, size: 0x8, addend: 0x0, symName: _UnityAssertGreaterOrLessFloat, symObjAddr: 0x24E0, symBinAddr: 0x1000049D0, symSize: 0x1A0 }
+  - { offset: 0x1D4C, size: 0x8, addend: 0x0, symName: _UnityAssertFloatSpecial, symObjAddr: 0x2680, symBinAddr: 0x100004B70, symSize: 0x600 }
+  - { offset: 0x1F36, size: 0x8, addend: 0x0, symName: _UnityAssertIntNumbersWithin, symObjAddr: 0x2C80, symBinAddr: 0x100005170, symSize: 0x150 }
+  - { offset: 0x1FA7, size: 0x8, addend: 0x0, symName: _UnityAssertUintNumbersWithin, symObjAddr: 0x2DD0, symBinAddr: 0x1000052C0, symSize: 0x150 }
+  - { offset: 0x2018, size: 0x8, addend: 0x0, symName: _UnityAssertNumbersArrayWithin, symObjAddr: 0x2F20, symBinAddr: 0x100005410, symSize: 0x4E0 }
+  - { offset: 0x2120, size: 0x8, addend: 0x0, symName: _UnityAssertEqualString, symObjAddr: 0x3400, symBinAddr: 0x1000058F0, symSize: 0x180 }
+  - { offset: 0x2182, size: 0x8, addend: 0x0, symName: _UnityPrintExpectedAndActualStrings, symObjAddr: 0x3580, symBinAddr: 0x100005A70, symSize: 0xA0 }
+  - { offset: 0x21B7, size: 0x8, addend: 0x0, symName: _UnityAssertEqualStringLen, symObjAddr: 0x3620, symBinAddr: 0x100005B10, symSize: 0x1A0 }
+  - { offset: 0x2228, size: 0x8, addend: 0x0, symName: _UnityPrintExpectedAndActualStringsLen, symObjAddr: 0x37C0, symBinAddr: 0x100005CB0, symSize: 0xB0 }
+  - { offset: 0x226C, size: 0x8, addend: 0x0, symName: _UnityAssertEqualStringArray, symObjAddr: 0x3870, symBinAddr: 0x100005D60, symSize: 0x2B0 }
+  - { offset: 0x231A, size: 0x8, addend: 0x0, symName: _UnityAssertEqualMemory, symObjAddr: 0x3B20, symBinAddr: 0x100006010, symSize: 0x2A0 }
+  - { offset: 0x23D6, size: 0x8, addend: 0x0, symName: _UnityNumToPtr, symObjAddr: 0x3DC0, symBinAddr: 0x1000062B0, symSize: 0xB0 }
+  - { offset: 0x240F, size: 0x8, addend: 0x0, symName: _UnityFloatToPtr, symObjAddr: 0x3E70, symBinAddr: 0x100006360, symSize: 0x20 }
+  - { offset: 0x2439, size: 0x8, addend: 0x0, symName: _UnityFail, symObjAddr: 0x3E90, symBinAddr: 0x100006380, symSize: 0xA0 }
+  - { offset: 0x246E, size: 0x8, addend: 0x0, symName: _UnityIgnore, symObjAddr: 0x3F30, symBinAddr: 0x100006420, symSize: 0xC0 }
+  - { offset: 0x24A3, size: 0x8, addend: 0x0, symName: _UnityMessage, symObjAddr: 0x3FF0, symBinAddr: 0x1000064E0, symSize: 0x70 }
+  - { offset: 0x24D8, size: 0x8, addend: 0x0, symName: _UnityDefaultTestRun, symObjAddr: 0x4060, symBinAddr: 0x100006550, symSize: 0xD0 }
+  - { offset: 0x251C, size: 0x8, addend: 0x0, symName: _UnitySetTestFile, symObjAddr: 0x4130, symBinAddr: 0x100006620, symSize: 0x20 }
+  - { offset: 0x2542, size: 0x8, addend: 0x0, symName: _UnityBegin, symObjAddr: 0x4150, symBinAddr: 0x100006640, symSize: 0xA0 }
+  - { offset: 0x2568, size: 0x8, addend: 0x0, symName: _UnityEnd, symObjAddr: 0x41F0, symBinAddr: 0x1000066E0, symSize: 0xC8 }
+...

runNeuralNetworkTests.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.runNeuralNetworkTests</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

runNeuralNetworkTests.dSYM/Contents/Resources/Relocations/x86_64/runNeuralNetworkTests.yml

@@ -0,0 +1,129 @@
+---
+triple:          'x86_64-apple-darwin'
+binary-path:     runNeuralNetworkTests
+relocations:
+  - { offset: 0x26, size: 0x8, addend: 0x0, symName: _test_loadModelReturnsCorrectNumberOfLayers, symObjAddr: 0x0, symBinAddr: 0x100000FD0, symSize: 0x250 }
+  - { offset: 0x5E, size: 0x8, addend: 0x0, symName: _test_loadModelReturnsCorrectNumberOfLayers, symObjAddr: 0x0, symBinAddr: 0x100000FD0, symSize: 0x250 }
+  - { offset: 0x126, size: 0x8, addend: 0x0, symName: _prepareNeuralNetworkFile, symObjAddr: 0x250, symBinAddr: 0x100001220, symSize: 0x150 }
+  - { offset: 0x1CA, size: 0x8, addend: 0x0, symName: _test_loadModelReturnsCorrectWeightDimensions, symObjAddr: 0x3A0, symBinAddr: 0x100001370, symSize: 0x1F0 }
+  - { offset: 0x256, size: 0x8, addend: 0x0, symName: _test_loadModelReturnsCorrectBiasDimensions, symObjAddr: 0x590, symBinAddr: 0x100001560, symSize: 0x1F0 }
+  - { offset: 0x2E2, size: 0x8, addend: 0x0, symName: _test_loadModelReturnsCorrectWeights, symObjAddr: 0x780, symBinAddr: 0x100001750, symSize: 0x240 }
+  - { offset: 0x37D, size: 0x8, addend: 0x0, symName: _test_loadModelReturnsCorrectBiases, symObjAddr: 0x9C0, symBinAddr: 0x100001990, symSize: 0x240 }
+  - { offset: 0x418, size: 0x8, addend: 0x0, symName: _test_loadModelFailsOnWrongFileTag, symObjAddr: 0xC00, symBinAddr: 0x100001BD0, symSize: 0xE0 }
+  - { offset: 0x474, size: 0x8, addend: 0x0, symName: _test_clearModelSetsMembersToNull, symObjAddr: 0xCE0, symBinAddr: 0x100001CB0, symSize: 0x230 }
+  - { offset: 0x500, size: 0x8, addend: 0x0, symName: _test_predictReturnsCorrectLabels, symObjAddr: 0xF10, symBinAddr: 0x100001EE0, symSize: 0x3B0 }
+  - { offset: 0x641, size: 0x8, addend: 0x0, symName: _someActivation, symObjAddr: 0x12C0, symBinAddr: 0x100002290, symSize: 0x70 }
+  - { offset: 0x681, size: 0x8, addend: 0x0, symName: _setUp, symObjAddr: 0x1330, symBinAddr: 0x100002300, symSize: 0x10 }
+  - { offset: 0x696, size: 0x8, addend: 0x0, symName: _tearDown, symObjAddr: 0x1340, symBinAddr: 0x100002310, symSize: 0x10 }
+  - { offset: 0x6AB, size: 0x8, addend: 0x0, symName: _main, symObjAddr: 0x1350, symBinAddr: 0x100002320, symSize: 0xF4 }
+  - { offset: 0xA85, size: 0x8, addend: 0x0, symName: _createMatrix, symObjAddr: 0x0, symBinAddr: 0x100002420, symSize: 0x90 }
+  - { offset: 0xA92, size: 0x8, addend: 0x0, symName: _createMatrix, symObjAddr: 0x0, symBinAddr: 0x100002420, symSize: 0x90 }
+  - { offset: 0xAD6, size: 0x8, addend: 0x0, symName: _clearMatrix, symObjAddr: 0x90, symBinAddr: 0x1000024B0, symSize: 0x50 }
+  - { offset: 0xAFA, size: 0x8, addend: 0x0, symName: _setMatrixAt, symObjAddr: 0xE0, symBinAddr: 0x100002500, symSize: 0x60 }
+  - { offset: 0xB48, size: 0x8, addend: 0x0, symName: _getMatrixAt, symObjAddr: 0x140, symBinAddr: 0x100002560, symSize: 0x70 }
+  - { offset: 0xB8C, size: 0x8, addend: 0x0, symName: _add, symObjAddr: 0x1B0, symBinAddr: 0x1000025D0, symSize: 0x230 }
+  - { offset: 0xC70, size: 0x8, addend: 0x0, symName: _multiply, symObjAddr: 0x3E0, symBinAddr: 0x100002800, symSize: 0x14C }
+  - { offset: 0xDAA, size: 0x8, addend: 0x0, symName: _loadModel, symObjAddr: 0x0, symBinAddr: 0x100002950, symSize: 0x190 }
+  - { offset: 0xE8C, size: 0x8, addend: 0x0, symName: _loadModel, symObjAddr: 0x0, symBinAddr: 0x100002950, symSize: 0x190 }
+  - { offset: 0xF26, size: 0x8, addend: 0x0, symName: _checkFileHeader, symObjAddr: 0x190, symBinAddr: 0x100002AE0, symSize: 0xD0 }
+  - { offset: 0xF7C, size: 0x8, addend: 0x0, symName: _readDimension, symObjAddr: 0x260, symBinAddr: 0x100002BB0, symSize: 0x50 }
+  - { offset: 0xFB2, size: 0x8, addend: 0x0, symName: _readLayer, symObjAddr: 0x2B0, symBinAddr: 0x100002C00, symSize: 0x80 }
+  - { offset: 0x1005, size: 0x8, addend: 0x0, symName: _isEmptyLayer, symObjAddr: 0x330, symBinAddr: 0x100002C80, symSize: 0x80 }
+  - { offset: 0x102D, size: 0x8, addend: 0x0, symName: _clearLayer, symObjAddr: 0x3B0, symBinAddr: 0x100002D00, symSize: 0x40 }
+  - { offset: 0x1051, size: 0x8, addend: 0x0, symName: _clearModel, symObjAddr: 0x3F0, symBinAddr: 0x100002D40, symSize: 0x70 }
+  - { offset: 0x1094, size: 0x8, addend: 0x0, symName: _assignActivations, symObjAddr: 0x460, symBinAddr: 0x100002DB0, symSize: 0x80 }
+  - { offset: 0x10D4, size: 0x8, addend: 0x0, symName: _argmax, symObjAddr: 0x4E0, symBinAddr: 0x100002E30, symSize: 0x110 }
+  - { offset: 0x1142, size: 0x8, addend: 0x0, symName: _predict, symObjAddr: 0x5F0, symBinAddr: 0x100002F40, symSize: 0x70 }
+  - { offset: 0x11B1, size: 0x8, addend: 0x0, symName: _imageBatchToMatrixOfImageVectors, symObjAddr: 0x660, symBinAddr: 0x100002FB0, symSize: 0x120 }
+  - { offset: 0x122D, size: 0x8, addend: 0x0, symName: _forward, symObjAddr: 0x780, symBinAddr: 0x1000030D0, symSize: 0x140 }
+  - { offset: 0x12B9, size: 0x8, addend: 0x0, symName: _readMatrix, symObjAddr: 0x8C0, symBinAddr: 0x100003210, symSize: 0x80 }
+  - { offset: 0x130B, size: 0x8, addend: 0x0, symName: _relu, symObjAddr: 0x940, symBinAddr: 0x100003290, symSize: 0xA0 }
+  - { offset: 0x134B, size: 0x8, addend: 0x0, symName: _softmax, symObjAddr: 0x9E0, symBinAddr: 0x100003330, symSize: 0x197 }
+  - { offset: 0x16D7, size: 0x8, addend: 0x0, symName: _UnityPrint, symObjAddr: 0x0, symBinAddr: 0x1000034D0, symSize: 0x60 }
+  - { offset: 0x16F0, size: 0x8, addend: 0x0, symName: _UnityStrOk, symObjAddr: 0x4390, symBinAddr: 0x100007A50, symSize: 0x0 }
+  - { offset: 0x1724, size: 0x8, addend: 0x0, symName: _UnityStrPass, symObjAddr: 0x4393, symBinAddr: 0x100007A53, symSize: 0x0 }
+  - { offset: 0x1745, size: 0x8, addend: 0x0, symName: _UnityStrFail, symObjAddr: 0x4398, symBinAddr: 0x100007A58, symSize: 0x0 }
+  - { offset: 0x175A, size: 0x8, addend: 0x0, symName: _UnityStrIgnore, symObjAddr: 0x439D, symBinAddr: 0x100007A5D, symSize: 0x0 }
+  - { offset: 0x177B, size: 0x8, addend: 0x0, symName: _UnityStrErrShorthand, symObjAddr: 0x43B0, symBinAddr: 0x100007A70, symSize: 0x0 }
+  - { offset: 0x179C, size: 0x8, addend: 0x0, symName: _UnityStrErrFloat, symObjAddr: 0x43E0, symBinAddr: 0x100007AA0, symSize: 0x0 }
+  - { offset: 0x17BD, size: 0x8, addend: 0x0, symName: _UnityStrErrDouble, symObjAddr: 0x4400, symBinAddr: 0x100007AC0, symSize: 0x0 }
+  - { offset: 0x17DE, size: 0x8, addend: 0x0, symName: _UnityStrErr64, symObjAddr: 0x4420, symBinAddr: 0x100007AE0, symSize: 0x0 }
+  - { offset: 0x17F3, size: 0x8, addend: 0x0, symName: _UnityStrErrDetailStack, symObjAddr: 0x4440, symBinAddr: 0x100007B00, symSize: 0x0 }
+  - { offset: 0x1808, size: 0x8, addend: 0x0, symName: _UnityPrintFloat, symObjAddr: 0x5D0, symBinAddr: 0x100003AA0, symSize: 0x6D0 }
+  - { offset: 0x182B, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.sig_digits, symObjAddr: 0x4464, symBinAddr: 0x100007B24, symSize: 0x0 }
+  - { offset: 0x1841, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.min_scaled, symObjAddr: 0x4468, symBinAddr: 0x100007B28, symSize: 0x0 }
+  - { offset: 0x1857, size: 0x8, addend: 0x0, symName: _UnityPrintFloat.max_scaled, symObjAddr: 0x446C, symBinAddr: 0x100007B2C, symSize: 0x0 }
+  - { offset: 0x1A27, size: 0x8, addend: 0x0, symName: _Unity, symBinAddr: 0x100009008, symSize: 0x0 }
+  - { offset: 0x1B0F, size: 0x8, addend: 0x0, symName: _UnityQuickCompare, symObjAddr: 0xAE68, symBinAddr: 0x100009000, symSize: 0x0 }
+  - { offset: 0x1BA8, size: 0x8, addend: 0x0, symName: _UnityStrExpected, symObjAddr: 0x4470, symBinAddr: 0x100007B30, symSize: 0x0 }
+  - { offset: 0x1BC9, size: 0x8, addend: 0x0, symName: _UnityStrWas, symObjAddr: 0x447B, symBinAddr: 0x100007B3B, symSize: 0x0 }
+  - { offset: 0x1BEA, size: 0x8, addend: 0x0, symName: _UnityStrSpacer, symObjAddr: 0x4605, symBinAddr: 0x100007CC5, symSize: 0x0 }
+  - { offset: 0x1BFF, size: 0x8, addend: 0x0, symName: _UnityStrDetail1Name, symObjAddr: 0x4608, symBinAddr: 0x100007CC8, symSize: 0x0 }
+  - { offset: 0x1C20, size: 0x8, addend: 0x0, symName: _UnityStrDetail2Name, symObjAddr: 0x4612, symBinAddr: 0x100007CD2, symSize: 0x0 }
+  - { offset: 0x1C35, size: 0x8, addend: 0x0, symName: _UnityStrGt, symObjAddr: 0x4490, symBinAddr: 0x100007B50, symSize: 0x0 }
+  - { offset: 0x1C56, size: 0x8, addend: 0x0, symName: _UnityStrLt, symObjAddr: 0x44B0, symBinAddr: 0x100007B70, symSize: 0x0 }
+  - { offset: 0x1C77, size: 0x8, addend: 0x0, symName: _UnityStrOrEqual, symObjAddr: 0x44C2, symBinAddr: 0x100007B82, symSize: 0x0 }
+  - { offset: 0x1C98, size: 0x8, addend: 0x0, symName: _UnityStrNotEqual, symObjAddr: 0x44D0, symBinAddr: 0x100007B90, symSize: 0x0 }
+  - { offset: 0x1CAD, size: 0x8, addend: 0x0, symName: _UnityStrPointless, symObjAddr: 0x44F0, symBinAddr: 0x100007BB0, symSize: 0x0 }
+  - { offset: 0x1CCE, size: 0x8, addend: 0x0, symName: _UnityStrNullPointerForExpected, symObjAddr: 0x4620, symBinAddr: 0x100007CE0, symSize: 0x0 }
+  - { offset: 0x1CEF, size: 0x8, addend: 0x0, symName: _UnityStrNullPointerForActual, symObjAddr: 0x4640, symBinAddr: 0x100007D00, symSize: 0x0 }
+  - { offset: 0x1D10, size: 0x8, addend: 0x0, symName: _UnityStrElement, symObjAddr: 0x4527, symBinAddr: 0x100007BE7, symSize: 0x0 }
+  - { offset: 0x1D25, size: 0x8, addend: 0x0, symName: _UnityStrInf, symObjAddr: 0x4531, symBinAddr: 0x100007BF1, symSize: 0x0 }
+  - { offset: 0x1D46, size: 0x8, addend: 0x0, symName: _UnityStrNegInf, symObjAddr: 0x4540, symBinAddr: 0x100007C00, symSize: 0x0 }
+  - { offset: 0x1D5B, size: 0x8, addend: 0x0, symName: _UnityStrNaN, symObjAddr: 0x4552, symBinAddr: 0x100007C12, symSize: 0x0 }
+  - { offset: 0x1D7C, size: 0x8, addend: 0x0, symName: _UnityStrDet, symObjAddr: 0x4556, symBinAddr: 0x100007C16, symSize: 0x0 }
+  - { offset: 0x1D9D, size: 0x8, addend: 0x0, symName: _UnityStrInvalidFloatTrait, symObjAddr: 0x4570, symBinAddr: 0x100007C30, symSize: 0x0 }
+  - { offset: 0x1DBE, size: 0x8, addend: 0x0, symName: _UnityStrNot, symObjAddr: 0x4584, symBinAddr: 0x100007C44, symSize: 0x0 }
+  - { offset: 0x1DD3, size: 0x8, addend: 0x0, symName: _UnityStrDelta, symObjAddr: 0x4590, symBinAddr: 0x100007C50, symSize: 0x0 }
+  - { offset: 0x1DF4, size: 0x8, addend: 0x0, symName: _UnityStrNull, symObjAddr: 0x4659, symBinAddr: 0x100007D19, symSize: 0x0 }
+  - { offset: 0x1E09, size: 0x8, addend: 0x0, symName: _UnityStrMemory, symObjAddr: 0x45B0, symBinAddr: 0x100007C70, symSize: 0x0 }
+  - { offset: 0x1E1E, size: 0x8, addend: 0x0, symName: _UnityStrByte, symObjAddr: 0x45C2, symBinAddr: 0x100007C82, symSize: 0x0 }
+  - { offset: 0x1E33, size: 0x8, addend: 0x0, symName: _UnityStrBreaker, symObjAddr: 0x45D0, symBinAddr: 0x100007C90, symSize: 0x0 }
+  - { offset: 0x1E54, size: 0x8, addend: 0x0, symName: _UnityStrResultsTests, symObjAddr: 0x45E8, symBinAddr: 0x100007CA8, symSize: 0x0 }
+  - { offset: 0x1E75, size: 0x8, addend: 0x0, symName: _UnityStrResultsFailures, symObjAddr: 0x45F0, symBinAddr: 0x100007CB0, symSize: 0x0 }
+  - { offset: 0x1E8A, size: 0x8, addend: 0x0, symName: _UnityStrResultsIgnored, symObjAddr: 0x45FB, symBinAddr: 0x100007CBB, symSize: 0x0 }
+  - { offset: 0x2003, size: 0x8, addend: 0x0, symName: _UnityPrint, symObjAddr: 0x0, symBinAddr: 0x1000034D0, symSize: 0x60 }
+  - { offset: 0x2035, size: 0x8, addend: 0x0, symName: _UnityPrintChar, symObjAddr: 0x60, symBinAddr: 0x100003530, symSize: 0xD0 }
+  - { offset: 0x2059, size: 0x8, addend: 0x0, symName: _UnityPrintLen, symObjAddr: 0x130, symBinAddr: 0x100003600, symSize: 0x130 }
+  - { offset: 0x2099, size: 0x8, addend: 0x0, symName: _UnityPrintNumberHex, symObjAddr: 0x260, symBinAddr: 0x100003730, symSize: 0x90 }
+  - { offset: 0x20EC, size: 0x8, addend: 0x0, symName: _UnityPrintIntNumberByStyle, symObjAddr: 0x2F0, symBinAddr: 0x1000037C0, symSize: 0x100 }
+  - { offset: 0x211E, size: 0x8, addend: 0x0, symName: _UnityPrintNumber, symObjAddr: 0x3F0, symBinAddr: 0x1000038C0, symSize: 0x50 }
+  - { offset: 0x2150, size: 0x8, addend: 0x0, symName: _UnityPrintUintNumberByStyle, symObjAddr: 0x440, symBinAddr: 0x100003910, symSize: 0x60 }
+  - { offset: 0x2182, size: 0x8, addend: 0x0, symName: _UnityPrintNumberUnsigned, symObjAddr: 0x4A0, symBinAddr: 0x100003970, symSize: 0x90 }
+  - { offset: 0x21B7, size: 0x8, addend: 0x0, symName: _UnityPrintMask, symObjAddr: 0x530, symBinAddr: 0x100003A00, symSize: 0xA0 }
+  - { offset: 0x229A, size: 0x8, addend: 0x0, symName: _UnityConcludeTest, symObjAddr: 0xCA0, symBinAddr: 0x100004170, symSize: 0xC0 }
+  - { offset: 0x22B0, size: 0x8, addend: 0x0, symName: _UnityTestResultsBegin, symObjAddr: 0xD60, symBinAddr: 0x100004230, symSize: 0x60 }
+  - { offset: 0x22E5, size: 0x8, addend: 0x0, symName: _UnityAssertBits, symObjAddr: 0xDC0, symBinAddr: 0x100004290, symSize: 0xE0 }
+  - { offset: 0x2347, size: 0x8, addend: 0x0, symName: _UnityTestResultsFailBegin, symObjAddr: 0xEA0, symBinAddr: 0x100004370, symSize: 0x40 }
+  - { offset: 0x236D, size: 0x8, addend: 0x0, symName: _UnityAddMsgIfSpecified, symObjAddr: 0xEE0, symBinAddr: 0x1000043B0, symSize: 0xA0 }
+  - { offset: 0x2393, size: 0x8, addend: 0x0, symName: _UnityAssertEqualIntNumber, symObjAddr: 0xF80, symBinAddr: 0x100004450, symSize: 0xD0 }
+  - { offset: 0x23F5, size: 0x8, addend: 0x0, symName: _UnityAssertEqualUintNumber, symObjAddr: 0x1050, symBinAddr: 0x100004520, symSize: 0xD0 }
+  - { offset: 0x2457, size: 0x8, addend: 0x0, symName: _UnityAssertIntGreaterOrLessOrEqualNumber, symObjAddr: 0x1120, symBinAddr: 0x1000045F0, symSize: 0x1A0 }
+  - { offset: 0x24D7, size: 0x8, addend: 0x0, symName: _UnityAssertUintGreaterOrLessOrEqualNumber, symObjAddr: 0x12C0, symBinAddr: 0x100004790, symSize: 0x1A0 }
+  - { offset: 0x2557, size: 0x8, addend: 0x0, symName: _UnityAssertEqualIntArray, symObjAddr: 0x1460, symBinAddr: 0x100004930, symSize: 0x3C0 }
+  - { offset: 0x264F, size: 0x8, addend: 0x0, symName: _UnityIsOneArrayNull, symObjAddr: 0x1820, symBinAddr: 0x100004CF0, symSize: 0xB0 }
+  - { offset: 0x26A6, size: 0x8, addend: 0x0, symName: _UnityAssertWithinFloatArray, symObjAddr: 0x18D0, symBinAddr: 0x100004DA0, symSize: 0x460 }
+  - { offset: 0x2830, size: 0x8, addend: 0x0, symName: _UnityFloatsWithin, symObjAddr: 0x1D30, symBinAddr: 0x100005200, symSize: 0x5F0 }
+  - { offset: 0x2AB4, size: 0x8, addend: 0x0, symName: _UnityAssertFloatsWithin, symObjAddr: 0x2320, symBinAddr: 0x1000057F0, symSize: 0xE0 }
+  - { offset: 0x2B16, size: 0x8, addend: 0x0, symName: _UnityAssertFloatsNotWithin, symObjAddr: 0x2400, symBinAddr: 0x1000058D0, symSize: 0xE0 }
+  - { offset: 0x2B78, size: 0x8, addend: 0x0, symName: _UnityAssertGreaterOrLessFloat, symObjAddr: 0x24E0, symBinAddr: 0x1000059B0, symSize: 0x1A0 }
+  - { offset: 0x2BE9, size: 0x8, addend: 0x0, symName: _UnityAssertFloatSpecial, symObjAddr: 0x2680, symBinAddr: 0x100005B50, symSize: 0x600 }
+  - { offset: 0x2DD3, size: 0x8, addend: 0x0, symName: _UnityAssertIntNumbersWithin, symObjAddr: 0x2C80, symBinAddr: 0x100006150, symSize: 0x150 }
+  - { offset: 0x2E44, size: 0x8, addend: 0x0, symName: _UnityAssertUintNumbersWithin, symObjAddr: 0x2DD0, symBinAddr: 0x1000062A0, symSize: 0x150 }
+  - { offset: 0x2EB5, size: 0x8, addend: 0x0, symName: _UnityAssertNumbersArrayWithin, symObjAddr: 0x2F20, symBinAddr: 0x1000063F0, symSize: 0x4E0 }
+  - { offset: 0x2FBD, size: 0x8, addend: 0x0, symName: _UnityAssertEqualString, symObjAddr: 0x3400, symBinAddr: 0x1000068D0, symSize: 0x180 }
+  - { offset: 0x301F, size: 0x8, addend: 0x0, symName: _UnityPrintExpectedAndActualStrings, symObjAddr: 0x3580, symBinAddr: 0x100006A50, symSize: 0xA0 }
+  - { offset: 0x3054, size: 0x8, addend: 0x0, symName: _UnityAssertEqualStringLen, symObjAddr: 0x3620, symBinAddr: 0x100006AF0, symSize: 0x1A0 }
+  - { offset: 0x30C5, size: 0x8, addend: 0x0, symName: _UnityPrintExpectedAndActualStringsLen, symObjAddr: 0x37C0, symBinAddr: 0x100006C90, symSize: 0xB0 }
+  - { offset: 0x3109, size: 0x8, addend: 0x0, symName: _UnityAssertEqualStringArray, symObjAddr: 0x3870, symBinAddr: 0x100006D40, symSize: 0x2B0 }
+  - { offset: 0x31B7, size: 0x8, addend: 0x0, symName: _UnityAssertEqualMemory, symObjAddr: 0x3B20, symBinAddr: 0x100006FF0, symSize: 0x2A0 }
+  - { offset: 0x3273, size: 0x8, addend: 0x0, symName: _UnityNumToPtr, symObjAddr: 0x3DC0, symBinAddr: 0x100007290, symSize: 0xB0 }
+  - { offset: 0x32AC, size: 0x8, addend: 0x0, symName: _UnityFloatToPtr, symObjAddr: 0x3E70, symBinAddr: 0x100007340, symSize: 0x20 }
+  - { offset: 0x32D6, size: 0x8, addend: 0x0, symName: _UnityFail, symObjAddr: 0x3E90, symBinAddr: 0x100007360, symSize: 0xA0 }
+  - { offset: 0x330B, size: 0x8, addend: 0x0, symName: _UnityIgnore, symObjAddr: 0x3F30, symBinAddr: 0x100007400, symSize: 0xC0 }
+  - { offset: 0x3340, size: 0x8, addend: 0x0, symName: _UnityMessage, symObjAddr: 0x3FF0, symBinAddr: 0x1000074C0, symSize: 0x70 }
+  - { offset: 0x3375, size: 0x8, addend: 0x0, symName: _UnityDefaultTestRun, symObjAddr: 0x4060, symBinAddr: 0x100007530, symSize: 0xD0 }
+  - { offset: 0x33B9, size: 0x8, addend: 0x0, symName: _UnitySetTestFile, symObjAddr: 0x4130, symBinAddr: 0x100007600, symSize: 0x20 }
+  - { offset: 0x33DF, size: 0x8, addend: 0x0, symName: _UnityBegin, symObjAddr: 0x4150, symBinAddr: 0x100007620, symSize: 0xA0 }
+  - { offset: 0x3405, size: 0x8, addend: 0x0, symName: _UnityEnd, symObjAddr: 0x41F0, symBinAddr: 0x1000076C0, symSize: 0xC8 }
+...