diff --git a/Priority/main b/Priority/main
new file mode 100755
index 0000000000000000000000000000000000000000..8a379b43b98d21c11e78b9a4e3ef06de39ede524
Binary files /dev/null and b/Priority/main differ
diff --git a/Priority/matrix.c b/Priority/matrix.c
new file mode 100644
index 0000000000000000000000000000000000000000..cd6561ae945f30956a3170e4d48aaef1ab6605fd
--- /dev/null
+++ b/Priority/matrix.c
@@ -0,0 +1,22 @@
+#include <stdlib.h>
+
+#define getAddress(matrix_pointer, current_row, current_column, columns) (matrix_pointer + current_row * columns + current_column)
+
+
+void initializeMatrix(long long* matrix, int rows, int cols) {
+	for (int i = 0; i < rows; i++) {
+		for (int j = 0; j < cols; j++) {
+			*getAddress(matrix, i, j, cols) = rand() % 100;
+		}
+	}
+}
+
+void multiplyMatrices(long long* matrixA, long long* matrixB, long long* matrixC, int rowsA, int colsA, int colsB) {
+	for (int i = 0; i < rowsA; i++) {
+		for(int j = 0; j < colsB; j++) {
+			for (int k = 0; k < colsA; k++) {
+				*getAddress(matrixC, i, j, colsB) += *getAddress(matrixA, i, k, colsA) * *getAddress(matrixB, k, j, colsB);
+			}
+		}
+    }
+}
\ No newline at end of file
diff --git a/Priority/matrix.h b/Priority/matrix.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8e5b0266badb9509e40e2d1828f33efe34e9eb1
--- /dev/null
+++ b/Priority/matrix.h
@@ -0,0 +1,3 @@
+void initializeMatrix(long long* matrix, int rows, int cols);
+
+void multiplyMatrices(long long* matrixA, long long* matrixB, long long* matrixC, int rowsA, int colsA, int colsB);
diff --git a/Priority/maximum.c b/Priority/maximum.c
new file mode 100644
index 0000000000000000000000000000000000000000..a6c04e4a2a387c9e5d76225bb6cfddd9a4835d56
--- /dev/null
+++ b/Priority/maximum.c
@@ -0,0 +1,78 @@
+#include "matrix.h"
+#include <limits.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+
+typedef struct parameters {
+    long long* arr;
+    int index;
+
+} param_t;
+
+
+int get_maximum(int* arr, int length) {
+    int max = 0;
+
+   for (int i = 0; i < length; i++) {
+        int value = *(arr + i);
+        if (value > max) {
+            max = value;
+        }
+    }
+
+    return max;
+}
+
+void* get_maximum_parallel(void* data) {
+    param_t *arr = ((param_t*) data);
+    
+    printf("%d\n", arr->index);
+
+    return NULL;
+}
+
+
+int main (int argc, const char* argv[]) {
+    if (argc != 4) {
+        printf("Usage: maximum <array length> <number of threads>\n");
+        exit(EXIT_FAILURE);
+    }
+
+    long threads = strtol(argv[1], NULL, 10);
+    long ROWS = strtol(argv[2], NULL, 10);
+    long COLS = strtol(argv[3], NULL, 10);
+
+
+    printf("Initializing...\n");
+    srand(time(NULL));
+    printf("Starting...\n");
+    struct timespec start, end;
+    clock_gettime(CLOCK_MONOTONIC, &start);
+
+    pthread_t pthreads[threads];
+    for (int i = 0; i < threads; i++) {
+        
+        param_t* data = (param_t*) malloc(sizeof(param_t));
+        data->arr = malloc(threads*sizeof(long long));
+        data->index = i;
+        if (pthread_create(&pthreads[i], NULL, get_maximum_parallel, data) != 0) {
+            printf("Could not create threads\n");
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    for (int i = 0; i < threads; i++) {
+        pthread_join(pthreads[i], NULL);
+    }
+
+    clock_gettime(CLOCK_MONOTONIC, &end);
+
+    //printf("Maximum: %d; determined in %ld ms\n", get_maximum(results, threads),
+    //    (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000 / 1000);
+
+    //free(arr);
+    //free(results);
+}
diff --git a/Priority/priority.c b/Priority/priority.c
new file mode 100644
index 0000000000000000000000000000000000000000..a796fd7e0b63b0a2513f636bd2c016721e7f3924
--- /dev/null
+++ b/Priority/priority.c
@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <time.h>
+#include "matrix.h"
+
+
+#define THREADS 10
+#define DIMENSION 1000
+
+struct param{
+    long long *matrixA;
+    long long *matrixB;
+    long long *matrixC;
+};
+
+typedef struct param param_t; 
+
+void *worker(void *param){
+    param_t *args = (param_t*)param;
+
+    struct timespec start, end;
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    
+    multiplyMatrices(args->matrixA, args->matrixB, args->matrixC, DIMENSION, DIMENSION, DIMENSION);
+    clock_gettime(CLOCK_MONOTONIC, &end);
+
+    long long *time = malloc(sizeof(long long));
+    *time = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000 / 1000;
+    return (void*) time;
+}
+
+
+int main(void){
+
+    pthread_t threads[THREADS];
+    param_t *parameters = malloc(sizeof(param_t));
+
+	parameters->matrixA = (long long*)malloc(DIMENSION * DIMENSION * sizeof(long long));
+    parameters->matrixB = (long long*)malloc(DIMENSION * DIMENSION * sizeof(long long));
+	parameters->matrixC = (long long*)malloc(DIMENSION * DIMENSION * sizeof(long long));
+
+    initializeMatrix(parameters->matrixA, DIMENSION, DIMENSION);
+	initializeMatrix(parameters->matrixB, DIMENSION, DIMENSION);
+    
+    for(int i = 0; i  < THREADS; i++){
+        if(pthread_create(&threads[i], NULL, worker, (void**)parameters) != 0){
+            perror("create error");
+            return -1;
+        }
+        if(i == 0){
+            struct sched_param param;
+            param.sched_priority = 99;
+            if(pthread_setschedparam(threads[i], SCHED_FIFO, &param)!=0){
+                perror("set prio fail");
+                return -1;
+            }
+        }
+    }
+    void *ret;
+    for(int i = 0; i < THREADS; i++){
+        if(pthread_join(threads[i], (void*)&ret) != 0){
+            perror("join error");
+            return -1;
+        }
+        long long *result = (long long*)ret;
+        printf("Thread %d: %lld ms\n", i,*result);
+    }
+
+    return 0;
+}