diff --git a/data.c b/data.c
index 5cda321..cc3718c 100644
--- a/data.c
+++ b/data.c
@@ -61,6 +61,14 @@ void char_array_print(const char_array_t *array) {
     printf("%s", array->data);
 };
 
+void char_array_print_hex(const char_array_t *array) {
+    printf("array: ");
+    for (int i = 0; i < array->size; i++) {
+        printf("%02x:", array->data[i]);
+    }
+    printf("\n");
+};
+
 void char_array_wipe(char_array_t *array) {
     array->size = 0;
     memset(array->data, 0, array->capacity);
@@ -96,8 +104,12 @@ char *char_array_get_bytes(char_array_t *array, size_t length) {
         return NULL;
     }
 
-    char *ret = malloc(length);
+    char *ret = calloc(length, sizeof(char));
+    printf("before: %c %02x:%02x:%02x:%02x %02x:%02x:%02x:%02x\n", ret[0], ret[1], ret[2], ret[3], ret[4], ret[5], ret[6], ret[7], ret[8]);
     memcpy(ret, array->data, length);
+    printf("after:  %c %02x:%02x:%02x:%02x %02x:%02x:%02x:%02x\n", ret[0], ret[1], ret[2], ret[3], ret[4], ret[5], ret[6], ret[7], ret[8]);
+    printf("weird: %x\n", ret[3]);
+    printf("weird: %x\n", array->data[3]);
     char_array_shift_bytes(array, length);
     return ret;
 }
@@ -110,4 +122,74 @@ void char_array_shift_bytes(char_array_t *array, size_t length) {
     memmove(array->data, array->data + length, array->size - length);
     array->size -= length;
 
+}
+
+byte_array_t *byte_array_create(int size) {
+    byte_array_t *array = malloc(sizeof(byte_array_t));
+    array->capacity = size;
+    array->size = 0;
+    array->data = calloc(size, sizeof(uint8_t));
+    return array;
+}
+void byte_array_destroy(byte_array_t *array) {
+    free(array->data);
+    free(array);
+};
+void byte_array_append(byte_array_t *array, byte *value, size_t length) {
+    if (array->data == NULL) {
+        exit(1);
+    }
+    size_t new_size = array->size + length;
+    if (new_size > array->capacity) {
+        array->capacity = new_size;
+        uint8_t *new_array = realloc(array->data, array->capacity);
+        array->data = new_array;
+        if (array->data == NULL) {}
+    }
+    memcpy(array->data+array->size, value, length);
+    array->size = new_size;
+}
+void byte_array_print(const byte_array_t *array) {
+    printf("btye_array size %llu: ", array->size);
+    for (int i = 0; i < array->size; i++) {
+        printf("%02x:", array->data[i]);
+    }
+    printf("\n");
+}
+uint8_t *byte_array_get_until_byte(byte_array_t *array, uint8_t b) {
+    size_t idx = 0;
+    for (size_t i = 0; i < array->size; i++) {
+        if (array->data[i] == b) {
+            idx = i;
+            break;
+        }
+    }
+    if (idx == 0) {
+        return NULL;
+    }
+    uint8_t *ret = malloc(idx+1);
+    memcpy(ret, array->data, idx);
+    ret[idx] = '\0';
+    byte_array_shift_bytes(array, idx+1);
+    return ret;
+}
+void byte_array_shift_bytes(byte_array_t *array, size_t length) {
+    if (length >= array->size) {
+        array->size = 0;
+        return;
+    }
+    memmove(array->data, array->data + length, array->size - length);
+    array->size -= length;
+}
+uint8_t *byte_array_get_bytes(byte_array_t *array, size_t length) {
+    if (length > array->size) {
+        return NULL;
+    }
+    // printf("array size: %llu\n", array->size);
+    uint8_t *ret = calloc(length, sizeof(uint8_t));
+    // printf("calloc done\n");
+    memcpy(ret, array->data, length);
+    // printf("memcpy done\n");
+    byte_array_shift_bytes(array, length);
+    return ret;
 }
\ No newline at end of file
diff --git a/data.h b/data.h
index 81e5a42..089475d 100644
--- a/data.h
+++ b/data.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <stdint.h>
 #include <stdio.h>
 #include <winsock2.h>
 typedef struct CharArray {
@@ -7,14 +8,30 @@ typedef struct CharArray {
     char *data;
 } char_array_t;
 
+typedef struct ByteArray {
+    size_t size;
+    size_t capacity;
+    uint8_t *data;
+} byte_array_t;
+
 char_array_t *char_array_create(int size);
 void char_array_destroy(char_array_t *array);
 void char_array_append(char_array_t *array, char *value, size_t length);
 void char_array_print(const char_array_t *array);
+void char_array_print_hex(const char_array_t *array);
 void char_array_wipe(char_array_t *array);
 bool char_array_has_char(char_array_t *array, char c);
 char *char_array_get_until_char(char_array_t *array, char c);
 char *char_array_get_bytes(char_array_t *array, size_t length);
 void char_array_shift_bytes(char_array_t *array, size_t length);
 
+byte_array_t *byte_array_create(int size);
+void byte_array_destroy(byte_array_t *array);
+void byte_array_append(byte_array_t *array, uint8_t *value, size_t length);
+void byte_array_print(const byte_array_t *array);
+uint8_t *byte_array_get_until_byte(byte_array_t *array, uint8_t b);
+uint8_t *byte_array_get_bytes(byte_array_t *array, size_t length);
+void byte_array_shift_bytes(byte_array_t *array, size_t length);
+
+
 SOCKET get_listen_socket();
\ No newline at end of file
diff --git a/server02.c b/server02.c
index fb42aea..a834dd1 100644
--- a/server02.c
+++ b/server02.c
@@ -27,20 +27,21 @@ int main() {
 }
 void *handle_connection(void *args) {
     handle_args_t *handleArgs = args;
-    char buffer[1024] = {0};
+    uint8_t buffer[1024] = {0};
     int bytesReceived;
-    char_array_t *data = char_array_create(1024);
+    byte_array_t *data = byte_array_create(1024);
     price_array_t *prices = price_array_create(1024);
     while ((bytesReceived = recv(handleArgs->client, buffer, sizeof(buffer), 0)) > 0) {
         printf("{%d} Client sent: |%d| \n", handleArgs->connection, bytesReceived);
-        char_array_append(data, buffer, bytesReceived);
-        char *raw_request;
-        while ((raw_request = char_array_get_bytes(data, 9)) != NULL) {
+        byte_array_append(data, buffer, bytesReceived);
+        // byte_array_print(data);
+        uint8_t *raw_request;
+        while ((raw_request = byte_array_get_bytes(data, 9)) != NULL) {
             //parse_request(handleArgs, request, data);
             query_or_insert_t *request = fix_message(raw_request);
             switch (request->insert.type) {
                 case INSERT:
-                    printf("{%d} timestamp: %d, price: %d\n", handleArgs->connection, request->insert.timestamp, request->insert.price);
+                    // printf("{%d} timestamp: %d, price: %d\n", handleArgs->connection, request->insert.timestamp, request->insert.price);
                     price_array_append(prices, &request->insert);
                     break;
                 case QUERY:
@@ -56,8 +57,7 @@ void *handle_connection(void *args) {
                     pthread_exit(NULL);
                     exit(3);
             }
-            free(request);
-            free(raw_request);
+
         }
         memset(buffer, 0, sizeof(buffer));
     }
@@ -69,12 +69,12 @@ void *handle_connection(void *args) {
 
 
 
-query_or_insert_t *fix_message(char *message) {
+query_or_insert_t *fix_message(const uint8_t *message) {
     if (message == NULL) {
         return NULL;
     }
     query_or_insert_t *ret = malloc(sizeof(query_or_insert_t));
-    ret->insert.type = message[0];
+    ret->insert.type = (char)message[0];
     ret->query.mintime = message[4] | (message[3] << 8) | (message[2] << 16) | (message[1] << 24);
     ret->query.maxtime = message[8] | (message[7] << 8) | (message[6] << 16) | (message[5] << 24);
     return ret;
@@ -98,23 +98,22 @@ void price_array_append(price_array_t *array, insert_t *value) {
     size_t new_size = array->size + 1;
     if (new_size > array->capacity) {
         array->capacity = array->capacity+1024;
-        price_t *new_array = realloc(array->data, array->capacity);
+        price_t *new_array = realloc(array->data, array->capacity * sizeof(price_t));
         array->data = new_array;
         if (array->data == NULL) {
             printf("Failed to allocate memory for array\n");
             exit(1);
         }
+        printf("array resized to %llu\n", array->capacity);
     }
-    price_t *temp = malloc(sizeof(price_t));
-    temp->timestamp = value->timestamp;
-    temp->price = value->price;
-    array->data[array->size] = *temp;
+    array->data[array->size].timestamp = value->timestamp;
+    array->data[array->size].price = value->price;
     array->size = new_size;
 };
 int price_array_query(price_array_t *array, query_t *query) {
 
     int count = 0;
-    int total = 0;
+    long long total = 0;
     for (int i = 0; i < array->size; i++) {
         if (array->data[i].timestamp >= query->mintime && array->data[i].timestamp <= query->maxtime) {
             count++;
diff --git a/server02.h b/server02.h
index 2d80487..bca1860 100644
--- a/server02.h
+++ b/server02.h
@@ -48,7 +48,7 @@ typedef struct PriceArray {
 } price_array_t;
 
 void *handle_connection(void *args);
-query_or_insert_t *fix_message(char *message);
+query_or_insert_t *fix_message(const uint8_t *message);
 
 price_array_t *price_array_create(int capacity);
 void price_array_free(price_array_t *array);