diff --git a/bucketsort_tri b/bucketsort_tri
new file mode 100755
index 0000000000000000000000000000000000000000..afd10b9f16185f8b91e4e9faa0a6f9911f32351f
Binary files /dev/null and b/bucketsort_tri differ
diff --git a/bucketsort_tri.c b/bucketsort_tri.c
new file mode 100644
index 0000000000000000000000000000000000000000..449539cf72c3d1fea6133f6a6c740bce123607af
--- /dev/null
+++ b/bucketsort_tri.c
@@ -0,0 +1,154 @@
+ 
+#include <omp.h> 
+#include <stdlib.h>
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct Bucket {
+    int num;
+    int* content;
+    int size;
+} Bucket;
+
+int *intdup(int const * src, size_t len)
+{
+   int * p = malloc(len * sizeof(int));
+   memcpy(p, src, len * sizeof(int));
+   return p;
+}
+
+int *createArray (int num_elements) {
+    int *rand_nums = (int *) malloc(sizeof(int) * num_elements);
+    int i;
+
+    srand(time(NULL));
+
+    for (i = 0; i < num_elements; i++ ) {
+        rand_nums[i] = (rand() % 100);
+       // printf(":%d ", rand_nums[i]);
+    }
+    //printf("\n");
+    return rand_nums;
+}
+
+int searchMax (int *array, int size) {
+    int max = 0;
+    int i = 0;
+    for (i = 0; i < size; i++ ) {
+        if ( array[i] > max  ) {
+            max = array[i];
+        }
+    }
+    return max;
+}
+
+Bucket* createBucket (int* array, int max_num, int array_size, int process) {
+    int total_bucket = process;
+    Bucket *buckets = (Bucket *) malloc(sizeof(Bucket) * total_bucket);
+
+    int content_size = (max_num / total_bucket) + 1;
+
+    int i = 0;
+    for (i = 0; i < total_bucket; i++) {
+        int *temp_bucket = (int *) malloc(sizeof(int) * array_size);
+        int n = 0;
+        int l = 0;
+
+        for (n = 0; n < array_size; n++) {
+            if (( array[n] >= i * content_size ) &&
+                ( array[n] < (i * content_size) + content_size )) {
+                temp_bucket[l] = array[n];
+                ++l;
+            }
+        }
+
+        buckets[i].num = i;
+        buckets[i].size = l;
+        buckets[i].content = intdup(temp_bucket, l);
+        free(temp_bucket);
+    }
+
+    return buckets;
+}
+
+int *insertionSort(int *array,int n){
+    int d,c,t;
+
+    for (c = 1 ; c <= n - 1; c++) {
+        d = c;
+
+        while ( d > 0 && array[d] < array[d-1]) {
+            t          = array[d];
+            array[d]   = array[d-1];
+            array[d-1] = t;
+
+            d--;
+        }
+    }
+
+    return array;
+}
+
+void printBucket (Bucket b) {
+    int i = 0;
+    printf("print: ");
+    for (i = 0; i < b.size; i++) {
+        printf("[%d]", b.content[i]);
+    }
+}
+
+void printArray (int *array, int size) {
+    int i;
+    //printf("Array Size : %d",size );
+    for (i = 0; i < size; i++) {
+        printf("[%d]", array[i]);
+    }
+    //printf("\n");
+}
+
+Bucket *buckets =NULL;
+
+void Hello(int **array,int* size){
+	
+      int world_rank = omp_get_thread_num();
+      int *sorted = insertionSort(buckets[world_rank].content, buckets[world_rank].size);
+      array[world_rank] = sorted;
+      size[world_rank] = buckets[world_rank].size;
+ }
+
+
+int main(int argc, char *argv[]) { 
+	 clock_t start, end;
+	
+	printf("Start");
+	start = clock();
+	
+
+        int thread_count = strtol(argv[1], NULL, 10); 
+        int world_rank = omp_get_thread_num();
+
+        int array_size = atoi(argv[2]);
+        int *array = NULL;
+        array = createArray(array_size);
+
+        buckets = createBucket(array, searchMax(array,array_size), array_size, thread_count);
+        //printBucket(buckets[0]);
+
+        int i = 0;
+
+        int *sorted_all[thread_count];
+        int sorted_size[thread_count];
+ 
+	#pragma omp parallel num_threads(thread_count) 
+	Hello(&(*sorted_all),&sorted_size); 
+
+      // for (i = 0; i < thread_count; i++){
+          // printArray(sorted_all[i], sorted_size[i]);
+       //}
+
+       end = clock();	
+       printf("Ending");
+       printf("Execution time : %f mseconds",(double)(end - start) * 1000.0 / CLOCKS_PER_SEC);
+       return 0; 
+} 
diff --git a/laporan.txt b/laporan.txt
new file mode 100644
index 0000000000000000000000000000000000000000..607ebed64ae52167a58ee038aac755bfa5dd2a10
--- /dev/null
+++ b/laporan.txt
@@ -0,0 +1,64 @@
+Laporan OpenMP
+Tjan Marco Orlando 13513038
+Lie Albert Tri	13513076
+
+
+
+Untuk Nilai N: 50.000
+1
+3560ms
+8
+610ms
+16
+430ms
+32
+370
+64
+430ms
+128
+60ms
+
+
+Untuk Nilai N: 100.000
+1
+14400ms
+8
+2130ms
+16
+1310ms
+32
+890ms
+64
+980ms
+128
+110ms
+
+Untuk Nilai N: 200.000
+1
+57620ms
+8
+7670ms
+16
+4350ms
+32
+2660ms
+64
+1620ms
+128
+190ms
+
+
+Untuk Nilai N: 400.000
+1
+232240ms
+8
+28620ms
+16
+15090ms
+32
+9020ms
+64
+5630ms
+128
+280ms
+
diff --git a/omp_hello.c b/omp_hello.c
new file mode 100644
index 0000000000000000000000000000000000000000..83228d793454eb8b7f7ba44ffc680ad1f3aeab6a
--- /dev/null
+++ b/omp_hello.c
@@ -0,0 +1,23 @@
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <omp.h> 
+ 
+void Hello(void); /* Thread function */ 
+ 
+	int main(int argc, char *argv[]) { 
+	int thread_count = strtol(argv[1], NULL, 10); 
+ 
+#pragma omp parallel num_threads(thread_count) 
+Hello(); 
+ 
+return 0; 
+} 
+ 
+void Hello(void) { 
+	int my_rank = omp_get_thread_num(); 
+	int thread_count = omp_get_num_threads(); 
+ 
+	printf("Hello from thread %d of %d\n", 
+	my_rank, thread_count); 
+} 
+