diff --git "a/imbalanced_manybugs.csv" "b/imbalanced_manybugs.csv"
new file mode 100644--- /dev/null
+++ "b/imbalanced_manybugs.csv"
@@ -0,0 +1,7379 @@
+text,label
+"#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define BSIZE 4
+#define NUMITEMS 30
+
+typedef struct {
+  char buf[BSIZE];
+  int occupied;
+  int nextin, nextout;
+  pthread_mutex_t mutex;
+  pthread_cond_t more;
+  pthread_cond_t less;
+} buffer_t;
+
+buffer_t buffer;
+
+void *producer(void *);
+void *consumer(void *);
+
+#define NUM_THREADS 2
+pthread_t tid[NUM_THREADS];
+
+int main(int argc, char *argv[])
+{
+  int i;
+
+  
+  buffer.occupied = 0;
+  buffer.nextin = 0;
+  buffer.nextout = 0;
+
+  pthread_mutex_init(&(buffer.mutex), NULL);
+  pthread_cond_init(&(buffer.more), NULL);
+  pthread_cond_init(&(buffer.less), NULL);
+
+  
+  pthread_create(&tid[0], NULL, producer, NULL);
+  pthread_create(&tid[1], NULL, consumer, NULL);
+
+
+  for (i = 0; i < NUM_THREADS; i++) {
+    pthread_join(tid[i], NULL);
+  }
+
+  printf(""\\nmain() reporting that all %d threads have terminated\\n"", NUM_THREADS);
+
+ 
+  pthread_mutex_destroy(&(buffer.mutex));
+  pthread_cond_destroy(&(buffer.more));
+  pthread_cond_destroy(&(buffer.less));
+
+  return 0;
+}
+
+void *producer(void *parm)
+{
+  char item[NUMITEMS] = ""IT'S A SMALL WORLD, AFTER ALL."";
+  int i;
+
+  printf(""producer started.\\n"");
+  fflush(stdout);
+
+  for(i = 0; i < NUMITEMS; i++) {
+    if (item[i] == '\\0') break;
+
+
+   
+
+    
+    while (buffer.occupied >= BSIZE) {
+      printf(""producer waiting.\\n"");
+      fflush(stdout);
+      pthread_cond_wait(&(buffer.less), &(buffer.mutex));
+    }
+
+  
+    buffer.buf[buffer.nextin++] = item[i];
+    buffer.nextin %= BSIZE;
+    buffer.occupied++;
+
+    printf(""producer produced: %c\\n"", item[i]);
+    fflush(stdout);
+
+    
+    pthread_cond_signal(&(buffer.more));
+   
+
+    
+    usleep(100000);
+  }
+
+  printf(""producer exiting.\\n"");
+  fflush(stdout);
+  pthread_exit(0);
+}
+
+void *consumer(void *parm)
+{
+  char item;
+  int i;
+
+  printf(""consumer started.\\n"");
+  fflush(stdout);
+
+  for(i = 0; i < NUMITEMS; i++) {
+   
+
+    
+    while(buffer.occupied <= 0) {
+      printf(""consumer waiting.\\n"");
+      fflush(stdout);
+      pthread_cond_wait(&(buffer.more), &(buffer.mutex));
+    }
+
+    
+    item = buffer.buf[buffer.nextout++];
+    buffer.nextout %= BSIZE;
+    buffer.occupied--;
+
+    printf(""consumer consumed: %c\\n"", item);
+    fflush(stdout);
+
+  
+    pthread_cond_signal(&(buffer.less));
+    
+
+    
+    usleep(150000);
+  }
+
+  printf(""consumer exiting.\\n"");
+  fflush(stdout);
+  pthread_exit(0);
+}
+
+",1
+"#include <stdio.h>
+#include <pthread.h>
+#include <errno.h>
+
+pthread_mutex_t lock_flag;
+int flag = 1;
+
+void *handlerA(void *arg)
+{
+	int i =0;
+	while(1)
+	{	
+		pthread_mutex_lock(&lock_flag);
+		if(flag == 1)
+		{
+		flag = 2;
+			printf(""handlerA:  A\\n"");
+		i++;
+		}
+		pthread_mutex_unlock(&lock_flag);
+			sleep(1);
+		if(i >= 10)
+			break;
+	}
+}
+void *handlerB(void *arg)
+{
+	int i = 0;
+	while(1)
+	{	
+		pthread_mutex_lock(&lock_flag);
+		if(flag == 2)
+		{
+		flag = 3;
+			printf(""handlerB:  B\\n"");
+		i++;
+		}
+		pthread_mutex_unlock(&lock_flag);
+		sleep(1);
+		if(i >= 10)
+		break;	
+	}
+
+}
+void *handlerC(void *arg)
+{
+	int i =0;
+	while(1)
+	{
+		pthread_mutex_lock(&lock_flag);
+		if(flag == 3)
+		{
+		flag = 1;
+			printf(""handlerC:  C\\n"");
+		i++;	
+		}
+		pthread_mutex_unlock(&lock_flag);
+		sleep(1);
+		if(i >= 10)
+		break;	
+	}
+	
+}
+
+int main()
+{
+	pthread_t pidA;
+	pthread_t pidB;
+	pthread_t pidC;
+
+	int ret;
+	pthread_mutex_init(&lock_flag,NULL);
+
+	ret = pthread_create(&pidA,NULL,handlerA,&flag);
+	if(ret < 0)
+	{
+		perror(""pthread create"");
+		return -1;
+	}
+
+	ret = pthread_create(&pidB,NULL,handlerB,&flag);
+	if(ret < 0)
+	{
+		perror(""pthread create"");
+		return -1;
+	}
+
+	ret = pthread_create(&pidC,NULL,handlerC,&flag);
+	if(ret < 0)
+	{
+		perror(""pthread create"");
+		return -1;
+	}
+
+	pthread_join(pidA,NULL);
+	pthread_join(pidB,NULL);
+	pthread_join(pidC,NULL);
+	return 0;
+}
+",0
+"#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NUM_THREADS  3
+#define TCOUNT 10
+#define COUNT_LIMIT 12
+
+int     count = 0;
+pthread_mutex_t count_mutex;
+pthread_cond_t count_threshold_cv;
+
+void *inc_count(void *t){
+      
+    int i;
+    long my_id = (long)t;
+
+    for(i=0; i < TCOUNT; i++){
+
+        count++;
+
+        if(count == COUNT_LIMIT){
+            
+            printf(""inc_count(): thread %ld, count = %d  Threshold reached. "",my_id, count);
+            pthread_cond_signal(&count_threshold_cv);
+            printf(""Just sent signal.\\n"");
+        }
+        
+        printf(""inc_count(): thread %ld, count = %d, unlocking mutex\\n"",my_id, count);
+
+                  
+        sleep(1);
+    }
+    
+    pthread_exit(NULL);
+}
+
+void *watch_count(void *t){
+
+    long my_id = (long)t;
+
+    printf(""Starting watch_count(): thread %ld\\n"", my_id);
+
+
+        
+    while(count < COUNT_LIMIT){
+        printf(""watch_count(): thread %ld Count= %d. Going into wait...\\n"", my_id,count);
+        pthread_cond_wait(&count_threshold_cv, &count_mutex);
+        printf(""watch_count(): thread %ld Condition signal received. Count= %d\\n"", my_id,count);
+        printf(""watch_count(): thread %ld Updating the value of count...\\n"", my_id,count);
+        count += 125;
+        printf(""watch_count(): thread %ld count now = %d.\\n"", my_id, count);
+    }
+          
+    printf(""watch_count(): thread %ld Unlocking mutex.\\n"", my_id);
+
+    pthread_exit(NULL);
+}
+
+void main(){
+
+    int i, rc; 
+    long t1=1, t2=2, t3=3;
+    pthread_t threads[3];
+    pthread_attr_t attr;
+
+    pthread_mutex_init(&count_mutex, NULL);
+    pthread_cond_init (&count_threshold_cv, NULL);
+
+
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
+    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
+    pthread_create(&threads[2], &attr, inc_count, (void *)t3);
+
+    for (i = 0; i < NUM_THREADS; i++) {
+        pthread_join(threads[i], NULL);
+    }
+    
+    printf (""Main(): Waited and joined with %d threads. Final value of count = %d. Done.\\n"", NUM_THREADS, count);
+
+
+    pthread_attr_destroy(&attr);
+    pthread_mutex_destroy(&count_mutex);
+    pthread_cond_destroy(&count_threshold_cv);
+    
+    pthread_exit (NULL);
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+void *producer(void *args);
+void *consumer(void *args);
+
+typedef struct {
+    int a_mem[0xffff];
+    int b_mem[0xffff];
+
+    pthread_mutex_t *a_mutex;
+    pthread_mutex_t *b_mutex;
+
+    int a_is_processing;
+    int b_is_processing;
+    int a_is_empty;
+    int b_is_empty;
+
+    pthread_cond_t *a_is_ready, *a_isnt_processing;
+    pthread_cond_t *b_is_ready, *b_isnt_processing;
+} queue;
+
+queue *queueInit(void);
+void queueDelete(queue *q);
+
+int main() {
+    queue *fifo;
+    pthread_t pro, con;
+
+    fifo = queueInit();
+    if (fifo == 0) {
+        fprintf(stderr, ""main: Queue Init failed.\\n"");
+        exit(1);
+    }
+
+    pthread_create(&pro, NULL, producer, fifo);
+    pthread_create(&con, NULL, consumer, fifo);
+    pthread_join(pro, NULL);
+    pthread_join(con, NULL);
+    queueDelete(fifo);
+
+    return 0;
+}
+
+void *producer(void *q) {
+    queue *fifo;
+    int i;
+
+    fifo = (queue *)q;
+
+    int fd = 0;
+    void *map_base = 0, *virt_addr = 0;
+
+    const uint32_t ALT_H2F_BASE = 0xC0000000;
+    const uint32_t ALT_H2F_OCM_OFFSET = 0x00000000;
+
+    off_t target = ALT_H2F_BASE;
+    unsigned long read_result;
+    int idx = 0;
+
+    if ((fd = open(""/dev/mem"", O_RDWR | O_SYNC)) == -1) {
+        fprintf(stderr, ""Error at line %d, file %s (%d) [%s]\\n"", __LINE__, __FILE__, errno, strerror(errno));
+        exit(1);
+    }
+    printf(""/dev/mem opened.\\n""); fflush(stdout);
+
+    map_base = mmap(0, 0x44000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, target & ~(0x44000 - 1));
+    printf(""Memory mapped at address %p.\\n"", map_base); fflush(stdout);
+    virt_addr = map_base + (target & (0x44000 - 1));
+
+    for (i = 0; i < 20; i++) {
+        pthread_mutex_lock(fifo->a_mutex);
+        while (fifo->a_is_processing) {
+            printf(""producer: memory A is processing.\\n"");
+            pthread_cond_wait(fifo->a_isnt_processing, fifo->a_mutex);
+        }
+
+        fifo->a_is_empty = 0;
+        printf(""producer: copying a\\n"");
+        for (idx = 0; idx < 0xffff; idx++) {
+            void* access_addr = virt_addr + ALT_H2F_OCM_OFFSET + idx * 4;
+            read_result = *((uint32_t*) access_addr);
+            fifo->a_mem[idx] = read_result;
+        }
+        printf(""producer: copying a (end)\\n"");
+        pthread_mutex_unlock(fifo->a_mutex);
+        pthread_cond_signal(fifo->a_is_ready);
+
+        pthread_mutex_lock(fifo->b_mutex);
+        while (fifo->b_is_processing) {
+            printf(""producer: memory B is processing.\\n"");
+            pthread_cond_wait(fifo->b_isnt_processing, fifo->b_mutex);
+        }
+
+        fifo->b_is_empty = 0;
+        printf(""producer: copying b\\n"");
+        for (idx = 0; idx < 0xffff; idx++) {
+            void* access_addr = virt_addr + ALT_H2F_OCM_OFFSET + idx * 4;
+            read_result = *((uint32_t*) access_addr);
+            fifo->b_mem[idx] = read_result;
+        }
+        printf(""producer: copying b (end)\\n"");
+        pthread_mutex_unlock(fifo->b_mutex);
+        pthread_cond_signal(fifo->b_is_ready);
+    }
+
+    if (munmap(map_base, 0x44000) == -1) {
+        fprintf(stderr, ""Error at line %d, file %s (%d) [%s]\\n"", __LINE__, __FILE__, errno, strerror(errno));
+        exit(1);
+    }
+    close(fd);
+
+    return NULL;
+}
+
+void *consumer(void *q) {
+    queue *fifo;
+    int i;
+
+    fifo = (queue *)q;
+
+    for (i = 0; i < 20; i++) {
+        pthread_mutex_lock(fifo->a_mutex);
+        while (fifo->a_is_empty) {
+            printf(""consumer: memory A is empty, wait producer.\\n"");
+            pthread_cond_wait(fifo->a_is_ready, fifo->a_mutex);
+        }
+
+        fifo->a_is_processing = 1;
+        printf(""image process A\\n"");
+        usleep(10);
+
+        fifo->a_is_processing = 0;
+        fifo->a_is_empty = 1;
+        pthread_mutex_unlock(fifo->a_mutex);
+        pthread_cond_signal(fifo->a_isnt_processing);
+
+        pthread_mutex_lock(fifo->b_mutex);
+        while (fifo->b_is_empty) {
+            printf(""consumer: memory B is empty, wait producer.\\n"");
+            pthread_cond_wait(fifo->b_is_ready, fifo->b_mutex);
+        }
+
+        fifo->b_is_processing = 1;
+        printf(""image process B\\n"");
+        usleep(10);
+
+        fifo->b_is_processing = 0;
+        fifo->b_is_empty = 1;
+        pthread_mutex_unlock(fifo->b_mutex);
+        pthread_cond_signal(fifo->b_isnt_processing);
+    }
+
+    return NULL;
+}
+
+queue *queueInit(void) {
+    queue *q;
+
+    q = (queue *)malloc(sizeof(queue));
+    if (q == NULL) return NULL;
+
+    q->a_is_processing = 0;
+    q->b_is_processing = 0;
+    q->a_is_empty = 1;
+    q->b_is_empty = 1;
+
+    q->a_mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+    pthread_mutex_init(q->a_mutex, NULL);
+    q->b_mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+    pthread_mutex_init(q->b_mutex, NULL);
+
+    q->a_is_ready = (pthread_cond_t *)malloc(sizeof(pthread_cond_t));
+    pthread_cond_init(q->a_is_ready, NULL);
+    q->b_is_ready = (pthread_cond_t *)malloc(sizeof(pthread_cond_t));
+    pthread_cond_init(q->b_is_ready, NULL);
+    q->a_isnt_processing = (pthread_cond_t *)malloc(sizeof(pthread_cond_t));
+    pthread_cond_init(q->a_isnt_processing, NULL);
+    q->b_isnt_processing = (pthread_cond_t *)malloc(sizeof(pthread_cond_t));
+    pthread_cond_init(q->b_isnt_processing, NULL);
+
+    return q;
+}
+
+void queueDelete(queue *q) {
+    pthread_mutex_destroy(q->a_mutex);
+    free(q->a_mutex);
+    pthread_mutex_destroy(q->b_mutex);
+    free(q->b_mutex);
+
+    pthread_cond_destroy(q->a_is_ready);
+    free(q->a_is_ready);
+    pthread_cond_destroy(q->b_is_ready);
+    free(q->b_is_ready);
+    pthread_cond_destroy(q->a_isnt_processing);
+    free(q->a_isnt_processing);
+    pthread_cond_destroy(q->b_isnt_processing);
+    free(q->b_isnt_processing);
+
+    free(q);
+}
+
+",0
+"#include <pthread.h>
+#include <iostream>
+#include <unistd.h>
+using namespace std;
+
+#define NUM_THREADS  3
+#define TCOUNT 10
+#define COUNT_LIMIT 12
+
+int count1 = 0;
+pthread_mutex_t count_mutex;
+pthread_cond_t count_threshold_cv;
+
+void *inc_count(void *t) {
+    long my_id = (long)t;
+
+    for (int i = 0; i < TCOUNT; i++) {
+
+        count1++;
+
+        if (count1 >= COUNT_LIMIT) {
+            cout << ""inc_count(): thread "" << my_id << "", count = "" << count1 << ""  Threshold reached. "";
+            pthread_cond_broadcast(&count_threshold_cv);
+            cout << ""Just sent signal.\\n"";
+        }
+        cout << ""inc_count(): thread "" << my_id << "", count = "" << count1 << "", unlocking mutex\\n"";
+
+        usleep(100);
+    }
+    pthread_exit(NULL);
+}
+
+void *watch_count(void *t) {
+    long my_id = (long)t;
+
+    cout << ""Starting watch_count(): thread "" << my_id << ""\\n"";
+    while (count1 < COUNT_LIMIT) {
+        cout << ""watch_count(): thread "" << my_id << "" Count= "" << count1 << "". Going into wait...\\n"";
+        pthread_cond_wait(&count_threshold_cv, &count_mutex);
+        cout << ""watch_count(): thread "" << my_id << "" Condition signal received. Count= "" << count1 << ""\\n"";
+    }
+
+
+    cout << ""watch_count(): thread "" << my_id << "" Updating the value of count...\\n"";
+    count1 += 125;
+    cout << ""watch_count(): thread "" << my_id << "" count now = "" << count1 << "".\\n"";
+    
+    cout << ""watch_count(): thread "" << my_id << "" Unlocking mutex.\\n"";
+
+    pthread_exit(NULL);
+}
+
+int main(int argc, char *argv[]) {
+    long t1 = 1, t2 = 2, t3 = 3;
+    pthread_t threads[3];
+    pthread_attr_t attr;
+
+    pthread_mutex_init(&count_mutex, NULL);
+    pthread_cond_init(&count_threshold_cv, NULL);
+
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
+    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
+    pthread_create(&threads[2], &attr, inc_count, (void *)t3);
+
+    for (int i = 0; i < NUM_THREADS; i++) {
+        pthread_join(threads[i], NULL);
+    }
+    cout << ""Main(): Waited and joined with "" << NUM_THREADS << "" threads. Final value of count = "" << count1 << "". Done.\\n"";
+
+    pthread_attr_destroy(&attr);
+    pthread_mutex_destroy(&count_mutex);
+    pthread_cond_destroy(&count_threshold_cv);
+    pthread_exit(NULL);
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <syslog.h>
+
+static int si_init_flag = 0;
+static int s_conf_fd = -1;
+static struct sockaddr_un s_conf_addr;
+static int s_buf_index = 0;
+static char s_conf_buf[4][(16384)];
+static pthread_mutex_t s_atomic;
+static char CONF_LOCAL_NAME[16] = ""/tmp/cfgClient"";
+
+inline int cfgSockSetLocal(const char *pLocalName)
+{
+    if (pLocalName)
+    {
+        snprintf(CONF_LOCAL_NAME, 15, ""%s"", pLocalName);
+        return 0;
+    }
+    else
+        return -1;
+}
+
+int cfgSockInit()
+{
+    if (si_init_flag)
+        return 0;
+
+    s_conf_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+    if (s_conf_fd < 0)
+    {
+        return -1;
+    }
+
+    if (0 != pthread_mutex_init(&s_atomic, 0))
+    {
+        close(s_conf_fd);
+        s_conf_fd = -1;
+
+        return -1;
+    }
+
+    unlink(CONF_LOCAL_NAME);
+
+    bzero(&s_conf_addr, sizeof(s_conf_addr));
+    s_conf_addr.sun_family = AF_UNIX;
+
+    snprintf(s_conf_addr.sun_path, sizeof(s_conf_addr.sun_path), ""%s"", CONF_LOCAL_NAME);
+
+    bind(s_conf_fd, (struct sockaddr *)&s_conf_addr, sizeof(s_conf_addr));
+
+    bzero(&s_conf_addr, sizeof(s_conf_addr));
+    s_conf_addr.sun_family = AF_UNIX;
+
+    snprintf(s_conf_addr.sun_path, sizeof(s_conf_addr.sun_path), ""/tmp/cfgServer"");
+
+    si_init_flag = 1;
+
+    return 0;
+}
+
+int cfgSockUninit()
+{
+    if (!si_init_flag)
+        return 0;
+
+    cfgSockSaveFiles();
+
+    if (s_conf_fd > 0)
+    {
+        close(s_conf_fd);
+    }
+
+    s_conf_fd = -1;
+
+    unlink(CONF_LOCAL_NAME);
+
+    pthread_mutex_destroy(&s_atomic);
+
+    si_init_flag = 0;
+
+    return 0;
+}
+
+static int cfgSockSend(const char *command)
+{
+    int ret = -1;
+
+    int addrlen = sizeof(s_conf_addr);
+    int len = strlen(command);
+
+    if (!si_init_flag)
+        return -1;
+
+    ret = sendto(s_conf_fd, command, len, 0, (struct sockaddr *)&s_conf_addr, addrlen);
+
+    if (ret != len)
+    {
+        close(s_conf_fd);
+        s_conf_fd = -1;
+
+        ret = -1;
+
+        si_init_flag = 0;
+        syslog(LOG_ERR, ""send conf message failed, ret = %d, errno %d\\n"", ret, errno);
+    }
+
+    return ret;
+}
+
+static int cfgSockRecv(char *buf, int len)
+{
+    int ret;
+    if (!si_init_flag)
+        return -1;
+
+    ret = recv(s_conf_fd, buf, len - 1, 0);
+    if (ret > 0)
+        buf[ret] = '\\0';
+    else
+        buf[0] = '\\0';
+
+    return ret;
+}
+
+static int cfgSockRequest(const char *command, char *recvbuf, int recvlen)
+{
+    int ret;
+
+    if (!command || !recvbuf || !recvlen)
+        return -1;
+
+    ret = cfgSockSend(command);
+    if (ret >= 0)
+    {
+        ret = cfgSockRecv(recvbuf, recvlen);
+    }
+
+    return ret;
+}
+
+const char *cfgSockGetValue(const char *a_pSection, const char *a_pKey, const char *a_pDefault)
+{
+    int nRet = -1;
+    char *conf_buf;
+
+    if (!si_init_flag || (!a_pSection && !a_pKey))
+        return 0;
+
+    pthread_mutex_lock(&s_atomic);
+    conf_buf = s_conf_buf[s_buf_index];
+
+    s_buf_index = (s_buf_index + 1) & 3;
+
+    if (a_pSection && a_pKey)
+    {
+        if (!a_pDefault)
+            snprintf(conf_buf, (16384), ""R %s.%s %s"", a_pSection, a_pKey, ""NULL"");
+        else
+            snprintf(conf_buf, (16384), ""R %s.%s %s"", a_pSection, a_pKey, a_pDefault);
+    }
+    else
+    {
+        const char *key = (a_pSection) ? a_pSection : a_pKey;
+
+        if (!a_pDefault)
+            snprintf(conf_buf, (16384), ""R %s %s"", key, ""NULL"");
+        else
+            snprintf(conf_buf, (16384), ""R %s %s"", key, a_pDefault);
+    }
+
+    cfgSockRequest(conf_buf, conf_buf, (16384));
+
+    pthread_mutex_unlock(&s_atomic);
+
+    nRet = strncmp(conf_buf, ""NULL"", 4);
+    if (0 == nRet)
+    {
+        return a_pDefault;
+    }
+
+    return conf_buf;
+}
+
+int cfgSockSetValue(const char *a_pSection, const char *a_pKey, const char *a_pValue)
+{
+    char *conf_buf;
+
+    if (!si_init_flag || (!a_pSection && !a_pKey) || !a_pValue)
+        return -1;
+
+    pthread_mutex_lock(&s_atomic);
+    conf_buf = s_conf_buf[s_buf_index];
+
+    s_buf_index = (s_buf_index + 1) & 3;
+
+    if (a_pSection && a_pKey)
+    {
+        snprintf(conf_buf, (16384), ""W %s.%s %s"", a_pSection, a_pKey, a_pValue);
+    }
+    else
+    {
+        const char *key = (a_pSection) ? a_pSection : a_pKey;
+
+        snprintf(conf_buf, (16384), ""W %s %s"", key, a_pValue);
+    }
+
+    cfgSockRequest(conf_buf, conf_buf, (16384));
+
+    pthread_mutex_unlock(&s_atomic);
+
+    return 0;
+}
+
+int cfgSockSaveFiles()
+{
+    char *conf_buf;
+    if (!si_init_flag)
+        return -1;
+
+    pthread_mutex_lock(&s_atomic);
+    conf_buf = s_conf_buf[s_buf_index];
+
+    s_buf_index = (s_buf_index + 1) & 3;
+
+    cfgSockRequest(""s"", conf_buf, (16384));
+
+    pthread_mutex_unlock(&s_atomic);
+
+    return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <err.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+struct employee {
+	int 	number;
+	int		id;
+	char	first_name[32];
+	char	last_name[32];
+	char	department[32];
+	int 	root_number;
+};
+
+
+struct employee employees[] = {
+	{ 1, 12345678, ""astro"", ""Bluse"", ""Accounting"", 101 },
+	{ 2, 87654321, ""Shrek"", ""Charl"", ""Programmer"", 102 },
+};
+
+
+struct employee employee_of_the_day;
+
+void copy_employee(struct employee *from, struct employee *to)
+{
+	memcpy(to, from, sizeof(struct employee));
+}
+
+pthread_mutex_t	lock = PTHREAD_MUTEX_INITIALIZER;
+
+void *do_loop(void *data)
+{
+	int num = *(int *)data;
+
+	while (1) {
+
+		copy_employee(&employees[num - 1], &employee_of_the_day);
+
+	}
+}
+
+
+int main(int argc, const char *argv[])
+{
+	pthread_t	th1, th2;
+	int			num1 = 1;
+	int 		num2 = 2;
+	int 		i;
+
+	copy_employee(&employees[0], &employee_of_the_day);
+
+	if (pthread_create(&th1, NULL, do_loop, &num1)) {
+		errx(EXIT_FAILURE, ""pthread_create() error.\\n"");
+	}
+	if (pthread_create(&th2, NULL, do_loop, &num2)) {
+		errx(EXIT_FAILURE, ""pthread_create() error.\\n"");
+	}
+
+	while (1) {
+
+		struct employee *p = &employees[employee_of_the_day.number - 1];
+
+		if (p->id != employee_of_the_day.id) {
+			printf(""mismatching 'id', %d != %d (loop '%d')\\n"", 
+								employee_of_the_day.id, p->id, i);
+			exit(EXIT_FAILURE);
+		}
+
+		if (strcmp(p->first_name, employee_of_the_day.first_name)) {
+			printf(""mismatching 'first_name', %s != %s (loop '%d')\\n"",
+								employee_of_the_day.first_name, p->first_name, i);
+			exit(EXIT_FAILURE);
+		}
+
+		if (strcmp(p->last_name, employee_of_the_day.last_name)) {
+			printf(""mismatching 'last_name', %s != %s (loop '%d')\\n"",
+								employee_of_the_day.last_name, p->last_name, i);
+			exit(EXIT_FAILURE);
+		}
+
+		if (strcmp(p->department, employee_of_the_day.department)) {
+			printf(""mismatching 'department', %s != %s (loop '%d')\\n"",
+								employee_of_the_day.department, p->department, i);
+			exit(EXIT_FAILURE);
+		}
+
+		if (p->root_number != employee_of_the_day.root_number) {
+			printf(""mismatching 'root_number', %d != %d (loop '%d')\\n"", 
+								employee_of_the_day.root_number, p->root_number, i);
+			exit(EXIT_FAILURE);
+		}
+		
+		printf(""lory, employees contents was always consistent\\n"");
+
+	}
+		
+	exit(EXIT_SUCCESS);
+}
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <errno.h>
+ 
+extern int K;
+extern int VECT_SIZE;
+extern int aHash[10];
+extern int bHash[10];
+extern int m[10];
+
+pthread_t ids[48];
+
+int nextLoc = -1;
+pthread_mutex_t m_nextLoc;
+
+int totalOnes = 0;
+pthread_mutex_t m_totalOnes;
+
+int numMemberships = 0;
+pthread_mutex_t m_numMemberships;
+
+int *M;
+int *checked;
+
+pthread_mutex_t *m_M;
+
+int nVertices;
+struct bloom *a;
+
+int ceilDiv(int a, int b);
+void *countOnes(void *x);
+void setM();
+void resetM();
+int checkLocation(int value, int *M);
+int setLocation(int value, int *M);
+int resetLocation(int value);
+void reconstruct0(int loc);
+void reconstruct1(int loc);
+void *reconstruct0_thread(void *x);
+void *reconstruct1_thread(void *x);
+
+int main(int argc, char *argv[]){
+ nVertices = atoi(argv[1]);
+ int nNodes = atoi(argv[2]);
+ K = atoi(argv[4]);
+ VECT_SIZE = atoi(argv[5]);
+ seiveInitial();
+
+ struct timespec start, finish, mid;
+ double elapsed, elapsed_m;
+
+ a = (struct bloom*)malloc(sizeof(struct bloom));
+ a->bloom_vector = (int*)malloc(sizeof(int)*(VECT_SIZE/NUM_BITS + 1));
+ init(a);
+
+ FILE *finput = fopen(argv[3],""r"");
+ int i = 0;
+ int val;
+ while (i<nNodes){
+  val = 0;
+  fscanf(finput,""%d\\n"",&val);
+  insert(val,a);
+  i++;
+ }
+ fclose(finput);
+
+
+ int size = ceilDiv(nVertices,NUM_BITS);
+
+ M = (int*)malloc(sizeof(int)*size);
+
+ checked = (int*)malloc(sizeof(int)*size);
+ for (i=0;i<size;i++) checked[i] = 0;
+
+ pthread_mutex_init(&m_nextLoc,0);
+ pthread_mutex_init(&m_totalOnes,0);
+ pthread_mutex_init(&m_numMemberships,0);
+ nextLoc = 0;
+ int rc;
+ clock_gettime(CLOCK_MONOTONIC, &start);
+ for (i=0;i<48;i++){
+  rc = pthread_create(&ids[i],0,countOnes,(void*)(i));
+ }
+ void *status;
+ for (i=0;i<48;i++){
+  pthread_join(ids[i],&status);
+ }
+
+ clock_gettime(CLOCK_MONOTONIC, &mid);
+
+ nextLoc = 0;
+ if (totalOnes < VECT_SIZE / 2){
+
+  resetM();
+  for (i=0;i<48;i++)
+   rc = pthread_create(&ids[i],0,reconstruct1_thread,(void*)(i));
+  for (i=0;i<48;i++)
+   pthread_join(ids[i],&status);
+ }
+ else{
+
+  setM();
+  for (i=0;i<48;i++)
+   rc = pthread_create(&ids[i],0,reconstruct0_thread,(void*)(i));
+  for (i=0;i<48;i++)
+   pthread_join(ids[i],&status);
+ }
+ clock_gettime(CLOCK_MONOTONIC, &finish);
+
+ elapsed_m = mid.tv_sec - start.tv_sec;
+ elapsed_m += (mid.tv_nsec - start.tv_nsec)/pow(10,9);
+ elapsed = finish.tv_sec - start.tv_sec;
+ elapsed += (finish.tv_nsec - start.tv_nsec)/pow(10,9);
+ totalOnes = 0;
+ for (i=0;i<size;i++) totalOnes += count_ones(M[i]);
+ printf(""RECONSTRUCTED SET OF SIZE %d IN TIME %lf WITH MEMBERSHIPS=%d\\n"",totalOnes, elapsed,numMemberships);
+
+
+}
+
+
+void *reconstruct0_thread(void *x){
+ while(1){
+  pthread_mutex_lock(&m_nextLoc);
+  int nL = nextLoc;
+  if (nL < ceilDiv (VECT_SIZE , NUM_BITS)){
+   nextLoc++;
+   pthread_mutex_unlock(&m_nextLoc);
+   reconstruct0(nL);
+  }
+  else{
+   pthread_mutex_unlock(&m_nextLoc);
+   pthread_exit(0);
+  }
+ }
+}
+
+void *reconstruct1_thread(void *x){
+ while(1){
+  pthread_mutex_lock(&m_nextLoc);
+  int nL = nextLoc;
+  if (nL < ceilDiv (VECT_SIZE , NUM_BITS)){
+   nextLoc++;
+   pthread_mutex_unlock(&m_nextLoc);
+   reconstruct1(nL);
+  }
+  else{
+   pthread_mutex_unlock(&m_nextLoc);
+   pthread_exit(0);
+  }
+ }
+}
+
+int ceilDiv(int a, int b){
+ return (a+b-1)/b;
+}
+
+void *countOnes(void *x){
+ while (1){
+  pthread_mutex_lock(&m_nextLoc);
+  int nL = nextLoc;
+  if (nL < ceilDiv (VECT_SIZE , NUM_BITS)){
+   nextLoc++;
+   pthread_mutex_unlock(&m_nextLoc);
+
+   int z = count_ones(a->bloom_vector[nL]);
+   if (z>0){
+    pthread_mutex_lock(&m_totalOnes);
+    totalOnes += z;
+    pthread_mutex_unlock(&m_totalOnes);
+   }
+  }
+  else{
+   pthread_mutex_unlock(&m_nextLoc);
+   pthread_exit(0);
+  }
+ }
+}
+
+void setM(){
+ int i;
+ int size = ceilDiv(nVertices,NUM_BITS);
+ for (i=0;i<size;i++) M[i] = M[i] | (~0);
+}
+
+void resetM(){
+ int i;
+ int size = ceilDiv(nVertices,NUM_BITS);
+ for (i=0;i<size;i++) M[i] = 0;
+}
+
+int checkLocation(int value, int *M){
+ int loc = value / NUM_BITS;
+ int off = value % NUM_BITS;
+ int retVal = 0;
+ if ((M[loc] & (1<<off)) != 0) retVal = 1;
+ return retVal;
+}
+
+int setLocation(int value, int *M){
+ int loc = value / NUM_BITS;
+ int off = value % NUM_BITS;
+ M[loc] = M[loc] | (1 << off);
+}
+
+int resetLocation(int value){
+ int loc = value / NUM_BITS;
+ int off = value % NUM_BITS;
+ M[loc] = M[loc] & (~(1 << off));
+}
+
+void reconstruct0(int loc){
+ int i;
+ for (i=loc*NUM_BITS;i<(loc+1)*NUM_BITS;i++){
+  int v = a->bloom_vector[loc] & (1 << (i%NUM_BITS));
+  if (v==0){
+   int h = 0;
+   for (h=0;h<3;h++){
+    int sample = 0, count = 0;
+    while (sample<nVertices){
+                                 if (((i-bHash[h])%aHash[h] + (count*m[h])%aHash[h])%aHash[h] == 0){
+                                         sample = ((int) (((double)i - bHash[h])/aHash[h] + ((double)count*m[h])/aHash[h]));
+                                         if (sample>0){
+       resetLocation(sample);
+      }
+                                 }
+                                 sample = ((int) (((double)i - bHash[h])/aHash[h] + ((double)count*m[h])/aHash[h]));
+                                 count++;
+                         }
+                        }
+  }
+ }
+}
+
+
+void reconstruct1(int loc){
+ int i;
+ int localCount = 0;
+ for (i=loc*NUM_BITS;i<(loc+1)*NUM_BITS;i++){
+  int v = a->bloom_vector[loc] & (1 << (i%NUM_BITS));
+
+  if (v!=0){
+   int h;
+   for (h=0;h<3;h++){
+    int sample = 0, count = 0;
+    while (sample<nVertices){
+     double cd = count, vd = m[h], ad = aHash[h], bd = bHash[h], s;
+     s = (i- bd + cd*vd)/ad;
+     sample = (int) s;
+     if (floor(s)==s){
+      if ((sample>0)&&(sample<nVertices)&&(!checkLocation(sample,checked))){
+       setLocation(sample,checked);
+       localCount++;
+       if (is_in(sample,a)){
+        setLocation(sample,M);
+       }
+      }
+     }
+     count++;
+    }
+   }
+  }
+ }
+ pthread_mutex_lock(&m_numMemberships);
+ numMemberships += localCount;
+ pthread_mutex_unlock(&m_numMemberships);
+}
+",0
+"#include ""helper.h""
+
+
+void pclock(char *msg, clockid_t cid) {
+    struct timespec ts;
+    printf(""%s"", msg);
+    if (clock_gettime(cid, &ts) == -1) {
+        perror(""clock_gettime"");
+        return;
+    }
+    printf(""%4ld.%03ld\\n"", ts.tv_sec, ts.tv_nsec / 1000000);
+}
+
+void errp(char *s, int code) {
+    fprintf(stderr, ""Error: %s -- %s\\n"", s, strerror(code));
+}
+
+void thr_sleep(time_t sec, long nsec) {
+    struct timeval now;
+    struct timezone tz;
+    struct timespec ts;
+    int retcode;
+
+    pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
+    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+
+    if(retcode) {
+        fprintf(stderr, ""Error: mutex_lock -- %s\\n"", strerror(retcode));
+        return;
+    }
+
+    gettimeofday(&now, &tz);
+    ts.tv_sec = now.tv_sec + sec + (nsec / 1000000000L);
+    ts.tv_nsec = (now.tv_usec * 1000) + (nsec % 1000000000L);
+    if(ts.tv_nsec > 1000000000L) {
+        (ts.tv_sec)++;
+        (ts.tv_nsec) -= 1000000000L;
+    }
+
+    retcode = pthread_cond_timedwait(&cond, &m, &ts);
+    if(retcode != ETIMEDOUT) {
+        if(retcode == 0) {
+            fprintf(stderr, ""pthread_cond_timedwait returned early.\\n"");
+        } else {
+            fprintf(stderr, ""pthread_cond_timedwait error: %s\\n"", strerror(retcode));
+            return;
+        }
+    }
+
+    if(retcode) {
+        fprintf(stderr, ""Error: mutex_unlock -- %s\\n"", strerror(retcode));
+        return;
+    }
+
+    pthread_cond_destroy(&cond);
+    pthread_mutex_destroy(&m);
+}
+
+void mulock(int ul, pthread_mutex_t *m) {
+    int retcode = 0;
+    char myErrStr[100];
+
+    if (ul) {
+        strcpy(myErrStr, ""mutex_unlock"");
+        retcode = pthread_mutex_unlock(m);
+    } else {
+        strcpy(myErrStr, ""mutex_lock"");
+        retcode = pthread_mutex_lock(m);
+    }
+    
+    if (retcode) {
+        fprintf(stderr, ""%s, %s\\n"", myErrStr, strerror(retcode));
+    }
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <limits.h>
+#include <libgen.h>
+
+#define PERFINDEX_FAILURE -1
+#define MAXPATHLEN 1024
+
+typedef struct parsed_args_struct {
+    char* my_name;
+    char* test_name;
+    int num_threads;
+    long long length;
+    int test_argc;
+    void** test_argv;
+} parsed_args_t;
+
+typedef struct test_struct {
+    int (*setup)(int, long long, int, void**);
+    int (*execute)(int, int, long long, int, void**);
+    int (*cleanup)(int, long long);
+    char** error_str_ptr;
+} test_t;
+
+parsed_args_t args;
+test_t test;
+int ready_thread_count = 0;
+pthread_mutex_t ready_thread_count_lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t start_cvar = PTHREAD_COND_INITIALIZER;
+pthread_cond_t threads_ready_cvar = PTHREAD_COND_INITIALIZER;
+
+int parse_args(int argc, char** argv, parsed_args_t* parsed_args) {
+    if (argc != 4) {
+        return -1;
+    }
+
+    parsed_args->my_name = argv[0];
+    parsed_args->test_name = argv[1];
+    parsed_args->num_threads = atoi(argv[2]);
+    parsed_args->length = strtoll(argv[3], NULL, 10);
+    parsed_args->test_argc = 0;
+    parsed_args->test_argv = NULL;
+    return 0;
+}
+
+void print_usage(char** argv) {
+    printf(""Usage: %s test_name threads length\\n"", argv[0]);
+}
+
+int find_test(char* test_name, char* test_path) {
+    char binpath[MAXPATHLEN];
+    char* dirpath;
+    uint32_t size = sizeof(binpath);
+    int retval;
+
+    retval = _NSGetExecutablePath(binpath, &size);
+    assert(retval == 0);
+    dirpath = dirname(binpath);
+
+    snprintf(test_path, MAXPATHLEN, ""%s/perfindex-%s.dylib"", dirpath, test_name);
+    return access(test_path, F_OK) == 0 ? 0 : -1;
+}
+
+int load_test(char* path, test_t* test) {
+    void* handle;
+    void* p;
+
+    handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
+    if (!handle) {
+        fprintf(stderr, ""dlopen error: %s\\n"", dlerror());
+        return -1;
+    }
+
+    p = dlsym(handle, ""setup"");
+    test->setup = (int (*)(int, long long, int, void**))p;
+
+    p = dlsym(handle, ""execute"");
+    test->execute = (int (*)(int, int, long long, int, void**))p;
+    if (p == NULL) {
+        fprintf(stderr, ""dlsym error: %s\\n"", dlerror());
+        return -1;
+    }
+
+    p = dlsym(handle, ""cleanup"");
+    test->cleanup = (int (*)(int, long long))p;
+
+    p = dlsym(handle, ""error_str"");
+    test->error_str_ptr = (char**)p;
+
+    return 0;
+}
+
+void start_timer(struct timeval* tp) {
+    gettimeofday(tp, NULL);
+}
+
+void end_timer(struct timeval* tp) {
+    struct timeval tend;
+    gettimeofday(&tend, NULL);
+    if (tend.tv_usec >= tp->tv_usec) {
+        tp->tv_sec = tend.tv_sec - tp->tv_sec;
+        tp->tv_usec = tend.tv_usec - tp->tv_usec;
+    } else {
+        tp->tv_sec = tend.tv_sec - tp->tv_sec - 1;
+        tp->tv_usec = tend.tv_usec - tp->tv_usec + 1000000;
+    }
+}
+
+void print_timer(struct timeval* tp) {
+    printf(""%ld.%06ld seconds\\n"", tp->tv_sec, (long)tp->tv_usec);
+}
+
+static void* thread_setup(void* arg) {
+    int my_index = (intptr_t)arg;
+    long long work_size = args.length / args.num_threads;
+    int work_remainder = args.length % args.num_threads;
+
+    if (work_remainder > my_index) {
+        work_size++;
+    }
+
+    pthread_mutex_lock(&ready_thread_count_lock);
+    ready_thread_count++;
+    if (ready_thread_count == args.num_threads)
+        pthread_cond_signal(&threads_ready_cvar);
+    pthread_cond_wait(&start_cvar, &ready_thread_count_lock);
+    pthread_mutex_unlock(&ready_thread_count_lock);
+
+    test.execute(my_index, args.num_threads, work_size, args.test_argc, args.test_argv);
+    return NULL;
+}
+
+int main(int argc, char** argv) {
+    int retval;
+    int thread_index;
+    struct timeval timer;
+    pthread_t* threads;
+    char test_path[MAXPATHLEN];
+
+    retval = parse_args(argc, argv, &args);
+    if (retval) {
+        print_usage(argv);
+        return -1;
+    }
+
+    retval = find_test(args.test_name, test_path);
+    if (retval) {
+        printf(""Unable to find test %s\\n"", args.test_name);
+        return -1;
+    }
+
+    retval = load_test(test_path, &test);
+    if (retval) {
+        printf(""Unable to load test %s\\n"", args.test_name);
+        return -1;
+    }
+
+    if (test.setup) {
+        retval = test.setup(args.num_threads, args.length, 0, NULL);
+        if (retval == PERFINDEX_FAILURE) {
+            fprintf(stderr, ""Test setup failed: %s\\n"", *test.error_str_ptr);
+            return -1;
+        }
+    }
+
+    threads = (pthread_t*)malloc(sizeof(pthread_t) * args.num_threads);
+    if (!threads) {
+        perror(""malloc"");
+        return -1;
+    }
+
+    for (thread_index = 0; thread_index < args.num_threads; thread_index++) {
+        retval = pthread_create(&threads[thread_index], NULL, thread_setup, (void*)(intptr_t)thread_index);
+        assert(retval == 0);
+    }
+
+    pthread_mutex_lock(&ready_thread_count_lock);
+    if (ready_thread_count != args.num_threads) {
+        pthread_cond_wait(&threads_ready_cvar, &ready_thread_count_lock);
+    }
+    pthread_mutex_unlock(&ready_thread_count_lock);
+
+    start_timer(&timer);
+    pthread_cond_broadcast(&start_cvar);
+    for (thread_index = 0; thread_index < args.num_threads; thread_index++) {
+        pthread_join(threads[thread_index], NULL);
+        if (**test.error_str_ptr) {
+            printf(""Test failed: %s\\n"", *test.error_str_ptr);
+        }
+    }
+    end_timer(&timer);
+
+    if (test.cleanup) {
+        retval = test.cleanup(args.num_threads, args.length);
+        if (retval == PERFINDEX_FAILURE) {
+            fprintf(stderr, ""Test cleanup failed: %s\\n"", *test.error_str_ptr);
+            free(threads);
+            return -1;
+        }
+    }
+
+    print_timer(&timer);
+    free(threads);
+
+    return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <math.h>
+
+#define GRID_SIZE 16384
+
+float** main_plate;
+float** main_prev_plate;
+char** main_locked_cells;
+
+pthread_barrier_t barrier_first;
+pthread_barrier_t barrier_second;
+pthread_mutex_t critical_begin_end;
+pthread_mutex_t runnable;
+
+typedef struct arg_plate {
+ int nthreads;
+ int begin;
+ int end;
+} arg_plate_t;
+
+double when() {
+ struct timeval tp;
+ gettimeofday(&tp, 0);
+ return ((double)tp.tv_sec + (double)tp.tv_usec * 1e-6);
+}
+
+
+float** createPlate() {
+ float** plate = (float**)malloc(16384 * sizeof(float*));
+ int k;
+ for (k = 0; k < 16384; k++) {
+  plate[k] = (float*)malloc(16384 * sizeof(float));
+ }
+ return plate;
+}
+char** createCharPlate() {
+ char** plate = (char**)malloc(16384 * sizeof(char*));
+ int k;
+ for (k = 0; k < 16384; k++) {
+  plate[k] = (char*)malloc(16384 * sizeof(char));
+ }
+ return plate;
+}
+void copy(float** main, float** result) {
+ int i,j;
+ for (i = 0; i < 16384; i++) {
+  for (j = 0; j < 16384; j++) {
+
+   result[i][j] = main[i][j];
+  }
+ }
+}
+
+void initPlate(float** plate, float** prev_plate) {
+ int i, j;
+ for (i = 0; i < 16384; i++) {
+  for (j = 0; j < 16384; j++) {
+   if (i == 0 || j == 0 || j == 16384 -1) {
+    plate[i][j] = 0;
+    prev_plate[i][j] = 0;
+    main_locked_cells[i][j] = '1';
+   }
+   else if (i == 16384 -1) {
+    plate[i][j] = 100;
+    prev_plate[i][j] = 100;
+    main_locked_cells[i][j] = '1';
+
+   }
+   else if (i == 400 && j >= 0 && j <= 330) {
+    plate[i][j] = 100;
+    prev_plate[i][j] = 100;
+    main_locked_cells[i][j] = '1';
+   }
+   else if (i == 200 && j == 500) {
+    plate[i][j] = 100;
+    prev_plate[i][j] = 100;
+    main_locked_cells[i][j] = '1';
+   }
+   else {
+    plate[i][j] = 50;
+    prev_plate[i][j] = 50;
+    main_locked_cells[i][j] = '0';
+   }
+  }
+ }
+ for (i = 0; i < 16384; i++) {
+  if ((i % 20) == 0) {
+   for (j = 0; j < 16384; j++) {
+    plate[i][j] = 100;
+    prev_plate[i][j] = 100;
+    main_locked_cells[i][j] = '1';
+   }
+  }
+ }
+ for (j = 0; j < 16384; j++) {
+  if ((j % 20) == 0) {
+   for (i = 0; i < 16384; i++) {
+    plate[i][j] = 0;
+    prev_plate[i][j] = 0;
+    main_locked_cells[i][j] = '1';
+   }
+  }
+ }
+}
+
+void cleanupFloat(float** plate) {
+ int i, j;
+ for (i = 0; i < 16384; i++) {
+  free(plate[i]);
+ }
+ free(plate);
+}
+void cleanupChar(char** plate) {
+ int i, j;
+ for (i = 0; i < 16384; i++) {
+  free(plate[i]);
+ }
+ free(plate);
+}
+
+void* update_plate(void* plate_arguments) {
+ for(;;) {
+  pthread_barrier_wait(&barrier_first);
+
+  arg_plate_t* plate_args = (arg_plate_t*)plate_arguments;
+
+
+  int begin = plate_args->begin;
+  int end = plate_args->end;
+
+
+
+  int i, j;
+  for (i = begin; i < end; i++) {
+   for (j = 0; j < 16384; j++) {
+    if (main_locked_cells[i][j] == '0') {
+     main_plate[i][j] = (main_prev_plate[i+1][j] + main_prev_plate[i][j+1] + main_prev_plate[i-1][j]
+       + main_prev_plate[i][j-1] + 4 * main_prev_plate[i][j]) * 0.125;
+    }
+   }
+  }
+
+  pthread_barrier_wait(&barrier_second);
+ }
+}
+char steady(float** current_plate) {
+ int count = 0;
+ int i, j;
+ float main_diff = 0;
+ for (i = 0; i < 16384; i++) {
+  for (j = 0; j < 16384; j++) {
+   if (main_locked_cells[i][j] == '0') {
+    if (current_plate[i][j] > 50)
+     count++;
+
+    float diff = fabs(current_plate[i][j] - (current_plate[i+1][j] + current_plate[i-1][j]
+       + current_plate[i][j+1] + current_plate[i][j-1]) * 0.25);
+    if (diff > main_diff)
+     main_diff = diff;
+   }
+  }
+ }
+
+ if (main_diff > 0.1)
+  return (1);
+ else
+  return (0);
+}
+
+void allocateWorkload(int nthreads, int* begin_end) {
+ int step = 16384 / nthreads;
+ int i;
+ int begin = 0;
+ for (i = 0; i < nthreads*2; i++) {
+  begin_end[i] = begin;
+
+  begin = begin+step;
+  i += 1;
+
+  begin_end[i] = begin;
+ }
+}
+
+int startUpdate(pthread_t* threads, int nthreads) {
+ printf(""Updating plate to steady state\\n"");
+
+ int iterations = 0;
+ int* begin_end = (int*)malloc((nthreads*2) * sizeof(int));
+ allocateWorkload(nthreads, begin_end);
+
+ int i;
+ int j;
+ pthread_t worker[nthreads];
+ arg_plate_t* plate_args;
+ for (i = 0; i < nthreads; i++) {
+
+
+  plate_args = (arg_plate_t*)malloc(sizeof(arg_plate_t));
+  j = i * 2;
+  plate_args->begin = begin_end[j];
+  plate_args->end = begin_end[j+1];
+
+  pthread_create(&worker[i], 0, &update_plate, (void*)plate_args);
+
+
+
+ }
+ do {
+  iterations++;
+  printf(""Iteration: %d\\n"", iterations);
+
+  pthread_barrier_wait(&barrier_first);
+  pthread_barrier_wait(&barrier_second);
+
+  copy(main_plate, main_prev_plate);
+
+ } while(steady(main_plate));
+ return iterations;
+}
+
+
+int main(int argc, char* argv[]) {
+
+ double start = when();
+ printf(""Starting time: %f\\n"", start);
+
+
+ int nthreads = atoi(argv[1]);
+ pthread_t threads[nthreads];
+
+
+ main_plate = createPlate();
+ main_prev_plate = createPlate();
+ main_locked_cells = createCharPlate();
+
+
+ initPlate(main_plate, main_prev_plate);
+
+
+ pthread_barrier_init(&barrier_first,0,nthreads+1);
+ pthread_barrier_init(&barrier_second,0,nthreads+1);
+ pthread_mutex_init(&critical_begin_end,0);
+ pthread_mutex_init(&runnable,0);
+
+
+ int iterations = startUpdate(threads, nthreads);
+
+
+ double end = when();
+ printf(""\\nEnding time: %f\\n"", end);
+ printf(""Total execution time: %f\\n"", end - start);
+ printf(""Number of iterations: %d\\n\\n"", iterations);
+
+
+ pthread_barrier_destroy(&barrier_first);
+ pthread_barrier_destroy(&barrier_second);
+ pthread_mutex_destroy(&critical_begin_end);
+ pthread_mutex_destroy(&runnable);
+
+
+ printf(""Cleanup\\n"");
+ cleanupFloat(main_plate);
+ cleanupFloat(main_prev_plate);
+ cleanupChar(main_locked_cells);
+
+ return 0;
+}
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+
+struct node {
+    char user[5];
+    char process;
+    int arrival;
+    int duration;
+    int priority;
+    struct node *next;
+}*head;
+
+struct display {
+    char user[5];
+    int timeLastCalculated;
+    struct display *next;
+}*frontDisplay, *tempDisplay, *rearDisplay;
+
+pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
+
+void initialise();
+void insert(char[5], char, int, int, int);
+void add(char[5], char, int, int, int);
+int count();
+void addafter(char[5], char, int, int, int, int);
+void* jobDisplay();
+void addToSummary(char[], int);
+void summaryDisplay();
+
+int main(int argc, char *argv[]) {
+    int n;
+    if (argc == 2) {
+        n = atoi(argv[1]);
+    } else if (argc > 2) {
+        printf(""Too many arguments supplied.\\n"");
+        return 0;
+    } else {
+        printf(""One argument expected.\\n"");
+        return 0;
+    }
+
+    char user[5], process;
+    int arrivalInput, durationInput, priorityInput;
+
+    initialise();
+    printf(""\\n\\tUser\\tProcess\\tArrival\\tRuntime\\tPriority\\n"");
+
+    int i = 1;
+    while (i < 5) {
+        printf(""\\t"");
+        if (scanf(""%s %c %d %d %d"", user, &process, &arrivalInput, &durationInput, &priorityInput) < 5) {
+            printf(""\\nThe arguments supplied are incorrect. Try again.\\n"");
+            return 0;
+        }
+        insert(user, process, arrivalInput, durationInput, priorityInput);
+        i++;
+    }
+
+    printf(""\\nThis would result in:\\n\\tTime\\tJob\\n"");
+
+    pthread_t threadID[n];
+    for (i = 0; i < n; i++) {
+        if (pthread_create(&threadID[i], NULL, &jobDisplay, NULL) != 0) {
+            perror(""Error creating thread"");
+            return 1;
+        }
+    }
+
+    for (i = 0; i < n; i++) {
+        pthread_join(threadID[i], NULL);
+    }
+
+    pthread_mutex_destroy(&m1);
+    pthread_mutex_destroy(&m2);
+    summaryDisplay();
+
+    return 0;
+}
+
+void initialise() {
+    head = NULL;
+    rearDisplay = NULL;
+    tempDisplay = NULL;
+    frontDisplay = NULL;
+}
+
+void insert(char user[5], char process, int arrival, int duration, int priority) {
+    int c = 0;
+    struct node *temp = head;
+
+    if (temp == NULL) {
+        add(user, process, arrival, duration, priority);
+    } else {
+        while (temp != NULL) {
+            if ((temp->arrival + temp->duration) < (arrival + duration)) {
+                c++;
+            }
+            temp = temp->next;
+        }
+        if (c == 0) {
+            add(user, process, arrival, duration, priority);
+        } else if (c < count()) {
+            addafter(user, process, arrival, duration, priority, ++c);
+        } else {
+            struct node *right;
+            temp = (struct node *)malloc(sizeof(struct node));
+            if (temp == NULL) {
+                perror(""Memory allocation failed"");
+                exit(1);
+            }
+
+            strcpy(temp->user, user);
+            temp->process = process;
+            temp->arrival = arrival;
+            temp->duration = duration;
+            temp->priority = priority;
+
+            right = head;
+            while (right->next != NULL) {
+                right = right->next;
+            }
+
+            right->next = temp;
+            temp->next = NULL;
+        }
+    }
+}
+
+void add(char user[5], char process, int arrival, int duration, int priority) {
+    struct node *temp = (struct node *)malloc(sizeof(struct node));
+    if (temp == NULL) {
+        perror(""Memory allocation failed"");
+        exit(1);
+    }
+
+    strcpy(temp->user, user);
+    temp->process = process;
+    temp->arrival = arrival;
+    temp->duration = duration;
+    temp->priority = priority;
+
+    if (head == NULL) {
+        head = temp;
+        head->next = NULL;
+    } else {
+        temp->next = head;
+        head = temp;
+    }
+}
+
+int count() {
+    struct node *n = head;
+    int c = 0;
+
+    while (n != NULL) {
+        n = n->next;
+        c++;
+    }
+    return c;
+}
+
+void addafter(char user[5], char process, int arrival, int duration, int priority, int loc) {
+    int i;
+    struct node *temp, *left, *right;
+    right = head;
+
+    for (i = 1; i < loc; i++) {
+        left = right;
+        right = right->next;
+    }
+
+    temp = (struct node *)malloc(sizeof(struct node));
+    if (temp == NULL) {
+        perror(""Memory allocation failed"");
+        exit(1);
+    }
+
+    strcpy(temp->user, user);
+    temp->process = process;
+    temp->arrival = arrival;
+    temp->duration = duration;
+    temp->priority = priority;
+
+    left->next = temp;
+    temp->next = right;
+}
+
+void* jobDisplay() {
+    pthread_mutex_lock(&m1);
+    struct node* placeholder = head;
+    pthread_mutex_unlock(&m1);
+
+    if (placeholder == NULL) {
+        pthread_exit(NULL);
+    }
+
+    int myTime = 0;
+    while (placeholder != NULL) {
+        if (myTime < placeholder->arrival) {
+            sleep(placeholder->arrival - myTime);
+            myTime = placeholder->arrival;
+        }
+
+        pthread_mutex_lock(&m1);
+        struct node* currentJob = placeholder;
+        pthread_mutex_unlock(&m1);
+
+        for (int i = 0; i < currentJob->duration; i++) {
+            printf(""\\t%d\\t%c\\n"", myTime, currentJob->process);
+            myTime++;
+            sleep(1);
+        }
+
+        addToSummary(currentJob->user, myTime);
+
+        pthread_mutex_lock(&m1);
+        placeholder = placeholder->next;
+        pthread_mutex_unlock(&m1);
+    }
+
+    printf(""\\t%d\\tIDLE\\n"", myTime);
+    pthread_exit(NULL);
+}
+
+void addToSummary(char name[], int timeLeft) {
+    pthread_mutex_lock(&m2);
+
+    if (rearDisplay == NULL) {
+        rearDisplay = (struct display *)malloc(sizeof(struct display));
+        if (rearDisplay == NULL) {
+            perror(""Memory allocation failed"");
+            pthread_mutex_unlock(&m2);
+            exit(1);
+        }
+
+        rearDisplay->next = NULL;
+        strcpy(rearDisplay->user, name);
+        rearDisplay->timeLastCalculated = timeLeft;
+        frontDisplay = rearDisplay;
+    } else {
+        tempDisplay = frontDisplay;
+        while (tempDisplay != NULL) {
+            if (strcmp(tempDisplay->user, name) == 0) {
+                tempDisplay->timeLastCalculated = timeLeft;
+                pthread_mutex_unlock(&m2);
+                return;
+            }
+            tempDisplay = tempDisplay->next;
+        }
+
+        tempDisplay = (struct display *)malloc(sizeof(struct display));
+        if (tempDisplay == NULL) {
+            perror(""Memory allocation failed"");
+            pthread_mutex_unlock(&m2);
+            exit(1);
+        }
+
+        rearDisplay->next = tempDisplay;
+        strcpy(tempDisplay->user, name);
+        tempDisplay->timeLastCalculated = timeLeft;
+        tempDisplay->next = NULL;
+        rearDisplay = tempDisplay;
+    }
+
+    pthread_mutex_unlock(&m2);
+}
+
+void summaryDisplay() {
+    printf(""\\n\\tSummary\\n"");
+
+    while (frontDisplay != NULL) {
+        printf(""\\t%s\\t%d\\n"", frontDisplay->user, frontDisplay->timeLastCalculated);
+        tempDisplay = frontDisplay->next;
+        free(frontDisplay);
+        frontDisplay = tempDisplay;
+    }
+    printf(""\\n"");
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <time.h>
+#include <stdbool.h>
+
+
+struct mode_extra_status
+{
+  int output_pipe_fd;
+  pthread_mutex_t mutex;
+  union switch_data answer;
+  long long rest_time[SWITCH_BUTTON_NUM + 1];
+  int score;
+  pthread_t background_worker;
+  bool terminated;
+};
+
+static void *background_worker_main (void *arg);
+
+struct mode_extra_status *mode_extra_construct (int output_pipe_fd)
+{
+  struct mode_extra_status *status;
+  status = malloc (sizeof (*status));
+
+  status->output_pipe_fd = output_pipe_fd;
+  pthread_mutex_init (&status->mutex, 0);
+  status->answer.val = 0;
+  status->score = 0;
+  status->terminated = 0;
+
+  pthread_create (&status->background_worker, 0, &background_worker_main, status);
+
+  return status;
+}
+
+void mode_extra_destroy (struct mode_extra_status *status)
+{
+  atomic_store_bool (&status->terminated, 1);
+  pthread_join (status->background_worker, 0);
+  pthread_mutex_destroy (&status->mutex);
+  free (status);
+}
+
+int mode_extra_switch (struct mode_extra_status *status, union switch_data data)
+{
+
+
+  int16_t correct = status->answer.val & data.val;
+  int16_t incorrect = (status->answer.val ^ data.val) & data.val;
+
+  LOG (LOGGING_LEVEL_HIGH, ""[Main Process] correct = %03X, incorrect = %03X."", correct, incorrect);
+
+  status->answer.val ^= correct;
+
+  for (int i = 0; i < SWITCH_BUTTON_NUM; ++i)
+    {
+      status->score += (correct & 1);
+      status->score -= (incorrect & 1);
+      correct >>= 1;
+      incorrect >>= 1;
+    }
+  if (status->score < 0)
+    status->score = 0;
+
+  output_message_fnd_send (status->output_pipe_fd, status->score);
+
+
+
+  return 0;
+}
+
+static void *background_worker_main (void *arg)
+{
+  struct mode_extra_status *status = arg;
+
+  long long prev_nano_time = get_nano_time ();
+  long long prev_creation_time = 0;
+
+  while (!atomic_load_bool (&status->terminated))
+    {
+
+
+      long long cur_nano_time = get_nano_time ();
+      long long time_gap = cur_nano_time - prev_nano_time;
+      prev_nano_time = cur_nano_time;
+# 110 ""mode_extra.c""
+      if (status->answer.bit_fields.s1) { status->rest_time[ 1 ] -= time_gap; if (status->rest_time[ 1 ] < 0) { status->answer.bit_fields.s1 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s2) { status->rest_time[ 2 ] -= time_gap; if (status->rest_time[ 2 ] < 0) { status->answer.bit_fields.s2 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s3) { status->rest_time[ 3 ] -= time_gap; if (status->rest_time[ 3 ] < 0) { status->answer.bit_fields.s3 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s4) { status->rest_time[ 4 ] -= time_gap; if (status->rest_time[ 4 ] < 0) { status->answer.bit_fields.s4 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s5) { status->rest_time[ 5 ] -= time_gap; if (status->rest_time[ 5 ] < 0) { status->answer.bit_fields.s5 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s6) { status->rest_time[ 6 ] -= time_gap; if (status->rest_time[ 6 ] < 0) { status->answer.bit_fields.s6 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s7) { status->rest_time[ 7 ] -= time_gap; if (status->rest_time[ 7 ] < 0) { status->answer.bit_fields.s7 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s8) { status->rest_time[ 8 ] -= time_gap; if (status->rest_time[ 8 ] < 0) { status->answer.bit_fields.s8 = 0; if (status->score > 0) --status->score; } };
+      if (status->answer.bit_fields.s9) { status->rest_time[ 9 ] -= time_gap; if (status->rest_time[ 9 ] < 0) { status->answer.bit_fields.s9 = 0; if (status->score > 0) --status->score; } };
+
+
+
+      long long delay_base = 300LL * 1000LL * 1000LL;
+      long long micro_delay = (rand () % 10 + 1) * delay_base;
+      double delay_coef = 5 / ((status->score + 10) / 20.0);
+
+      if (cur_nano_time - prev_creation_time > delay_coef * delay_base)
+        {
+          int no = 1 + rand () % SWITCH_BUTTON_NUM;
+          status->rest_time[no] = micro_delay;
+          status->answer.val |= (1 << (no-1));
+          prev_creation_time = cur_nano_time;
+        }
+
+      output_message_fnd_send (status->output_pipe_fd, status->score);
+
+      struct dot_matrix_data dot_data = { { { 0, }, } };
+      int16_t bit_mask = 1;
+      const int x_jump = 2, x_size = 3;
+      const int y_jump = 3, y_size = 4;
+      for (int i = 0; i < 3; ++i)
+        {
+          for (int j = 0; j < 3; ++j)
+            {
+              if (status->answer.val & bit_mask)
+                {
+                  int base_y = i * y_jump;
+                  int base_x = j * x_jump;
+                  for (int y = base_y; y < base_y + y_size; ++y)
+                    for (int x = base_x; x < base_x + x_size; ++x)
+                      dot_data.data[y][x] = 1;
+                }
+              bit_mask <<= 1;
+            }
+        }
+      output_message_dot_matrix_send (status->output_pipe_fd, &dot_data);
+
+
+
+      usleep ((10*1000));
+    }
+
+  return 0;
+}
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <string.h>
+#include <time.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#define MAX_CHANNEL 6
+
+static pthread_t threadTickGenerator;
+static pthread_t threadFIFO2DA[MAX_CHANNEL];
+static pthread_mutex_t mutexTick[MAX_CHANNEL];
+static pthread_cond_t condTick[MAX_CHANNEL];
+
+int debug = 0;
+
+int readAChar(int fifoFD) {
+    char aChar;
+    int err = read(fifoFD, &aChar, 1);
+    if (err < 0) {
+        perror(""read"");
+        return -1;
+    } else if (err == 0) {
+        sleep(1);
+        return -2;
+    }
+    return (int)aChar;
+}
+
+void waitTick(int Channel) {
+    pthread_mutex_lock(&mutexTick[Channel]);
+    pthread_cond_wait(&condTick[Channel], &mutexTick[Channel]);
+    pthread_mutex_unlock(&mutexTick[Channel]);
+}
+
+void *functionTickGenerator(void *param) {
+    int Channel;
+    for (Channel = 0; Channel < MAX_CHANNEL; Channel++) {
+        pthread_mutex_init(&mutexTick[Channel], NULL);
+        pthread_cond_init(&condTick[Channel], NULL);
+    }
+
+    while (1) {
+        struct timespec sleepTime = {0, 40 * 1000000};
+        
+        for (Channel = 0; Channel < MAX_CHANNEL; Channel++) {
+            pthread_mutex_lock(&mutexTick[Channel]);
+            pthread_cond_signal(&condTick[Channel]);
+            pthread_mutex_unlock(&mutexTick[Channel]);
+        }
+
+        nanosleep(&sleepTime, NULL);
+    }
+
+    return NULL;
+}
+
+void *functionFIFO2DA(void *param) {
+    int channel = (intptr_t)param;
+    char stringFIFO[32];
+    int fifoFD;
+
+    pthread_detach(pthread_self());
+    snprintf(stringFIFO, sizeof(stringFIFO), ""/tmp/FIFO_CHANNEL%d"", channel);
+    fifoFD = open(stringFIFO, O_RDONLY);
+    if (fifoFD < 0) {
+        perror(""open"");
+        if (mkfifo(stringFIFO, 0777) != 0) {
+            perror(""mkfifo"");
+            goto threadError;
+        }
+        fifoFD = open(stringFIFO, O_RDONLY);
+        if (fifoFD < 0) {
+            perror(""open after mkfifo"");
+            goto threadError;
+        }
+    }
+
+    while (1) {
+        char readBuffer[512 * 1024];
+        char *walkInBuffer = readBuffer;
+        int readSize;
+        int stringIndex;
+        int readInt;
+        char *toNullPos;
+
+        readSize = read(fifoFD, readBuffer, sizeof(readBuffer));
+        if (readSize <= 0) {
+            struct timespec sleepTime = {0, 40 * 1000000};
+            nanosleep(&sleepTime, NULL);
+            continue;
+        }
+
+        if (debug) printf(""ch%d:"", channel);
+        do {
+            toNullPos = strchr(walkInBuffer, ',');
+            if (toNullPos) *toNullPos = '\\0';
+
+            stringIndex = sscanf(walkInBuffer, ""0x%x"", &readInt);
+            if (stringIndex == 0) {
+                stringIndex = sscanf(walkInBuffer, ""%d"", &readInt);
+                if (stringIndex == 0) {
+                    fprintf(stderr, ""Invalid number: %s\\n"", walkInBuffer);
+                    if (toNullPos) {
+                        walkInBuffer = toNullPos + 1;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+            }
+
+            writeDAC(channel, readInt);
+            waitTick(channel);
+
+            if (toNullPos)
+                walkInBuffer = toNullPos + 1;
+            else
+                break;
+        } while (strlen(walkInBuffer) > 0);
+
+        if (debug) printf(""\\n"");
+    }
+
+threadError:
+    printf(""Channel %d exit\\n"", channel);
+    if (fifoFD >= 0) close(fifoFD);
+    return NULL;
+}
+
+static const int maxValue[MAX_CHANNEL] = {
+    120,
+    240,
+    60,
+    30,
+    30,
+    30
+};
+
+int cpap2psg(int rs232_descriptor, char *cmdBuffer, int cmdSize, int checkedXor) {
+    int expectedLength = 5;
+
+    if (sendCPAPCmd(rs232_descriptor, cmdBuffer, cmdSize, checkedXor))
+        return -1;
+
+    unsigned char responseBuffer[1024];
+    int responseSize;
+    responseSize = recvCPAPResponse(rs232_descriptor, responseBuffer, sizeof(responseBuffer), expectedLength);
+
+    if (responseSize < 0) {
+        return responseSize;
+    }
+
+    int adjustedValue = (65535.0 / maxValue[0]) * responseBuffer[2];
+    if (debug) printf(""cpap:%d -> da:%d\\n"", responseBuffer[2], adjustedValue);
+
+    writeDAC(0, adjustedValue);
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (access(""/etc/debug"", F_OK) == 0)
+        debug = 1;
+
+    int rs232_descriptor;
+    char cmdBuffer[2] = {0x93, 0xCB};
+    int cmdSize = sizeof(cmdBuffer);
+    int checkedXor;
+
+    initDAC();
+
+    int deviceDesc = openCPAPDevice();
+    checkedXor = getCheckedXor(cmdBuffer, cmdSize);
+
+    pthread_create(&threadTickGenerator, NULL, functionTickGenerator, NULL);
+
+    while (1) {
+        int err = cpap2psg(deviceDesc, cmdBuffer, cmdSize, checkedXor);
+        if (err == -2) {
+            deviceDesc = openCPAPDevice();
+        }
+        sleep(1);
+
+        for (int channel = 0; channel < MAX_CHANNEL; channel++) {
+            if (threadFIFO2DA[channel] == 0) {
+                pthread_create(&threadFIFO2DA[channel], NULL, functionFIFO2DA, (void *)(intptr_t)channel);
+            }
+        }
+    }
+
+    rs232_close(rs232_descriptor);
+
+    return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h> 
+#include <unistd.h>
+#include <semaphore.h>
+#include <time.h>
+
+#define THREAD_NUM 4
+#define BUFFER_SIZE 256
+
+typedef struct Task{
+   int a, b;
+}Task;
+
+Task taskQueue[BUFFER_SIZE];
+int taskCount = 0;
+
+pthread_mutex_t mutex;
+
+pthread_cond_t condFull;
+pthread_cond_t condEmpty;
+
+void executeTask(Task* task, int id){
+   int result = task->a + task->b;
+   printf(""(Thread %d) Sum of %d and %d is %d\\n"", id, task->a, task->b, result);
+}
+
+Task getTask(){
+
+   
+   while (taskCount == 0){
+      pthread_cond_wait(&condEmpty, &mutex);
+   }
+   
+   Task task = taskQueue[0];
+   int i;
+   for (i = 0; i < taskCount - 1; i++){
+      taskQueue[i] = taskQueue[i+1];
+   }
+   taskCount--;
+   
+
+   pthread_cond_signal(&condFull);
+   return task;
+}
+
+void submitTask(Task task){
+
+
+   while (taskCount == BUFFER_SIZE){
+      pthread_cond_wait(&condFull, &mutex);
+   }
+
+   taskQueue[taskCount] = task;
+   taskCount++;
+
+ 
+   pthread_cond_signal(&condEmpty);
+}
+
+void *startThread(void* args);  
+
+/*--------------------------------------------------------------------*/
+int main(int argc, char* argv[]) {
+   pthread_mutex_init(&mutex, NULL);
+   
+   pthread_cond_init(&condEmpty, NULL);
+   pthread_cond_init(&condFull, NULL);
+
+   pthread_t thread[THREAD_NUM]; 
+   long i;
+   for (i = 0; i < THREAD_NUM; i++){  
+      if (pthread_create(&thread[i], NULL, &startThread, (void*) i) != 0) {
+         perror(""Failed to create the thread"");
+      }  
+   }
+   
+   srand(time(NULL));
+   for (i = 0; i < 500; i++){
+      Task t = {
+         .a = rand() % 100,
+         .b = rand() % 100
+      };
+      submitTask(t);
+   }
+   
+   for (i = 0; i < THREAD_NUM; i++){  
+      if (pthread_join(thread[i], NULL) != 0) {
+         perror(""Failed to join the thread"");
+      }  
+   }
+   
+   pthread_mutex_destroy(&mutex);
+   pthread_cond_destroy(&condEmpty);
+   pthread_cond_destroy(&condFull);
+   return 0;
+}  /* main */
+
+/*-------------------------------------------------------------------*/
+void *startThread(void* args) {
+    long id = (long) args;
+    while (1) {
+        Task task = getTask();
+        if (task.a == -1 && task.b == -1) {  // Check for termination task
+            printf(""(Thread %ld) Terminating\\n"", id);
+            break;  // Exit the loop
+        }
+        executeTask(&task, id);
+        sleep(rand() % 5);
+    }
+    return NULL;
+}
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <sys/epoll.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <time.h>
+
+#define MAX_CHANNEL 5
+#define LISTEN_BACKLOG 50
+
+pthread_t thread[MAX_CHANNEL];
+pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
+
+int clients[100];
+char msg[100];
+int max_clients = 100;
+
+int setnonblocking(int sock) {
+    int opts = fcntl(sock, F_GETFL);
+    if (opts < 0) {
+        perror(""fcntl(F_GETFL)"");
+        return -1;
+    }
+    opts = opts | O_NONBLOCK;
+    if (fcntl(sock, F_SETFL, opts) < 0) {
+        perror(""fcntl(F_SETFL)"");
+        return -1;
+    }
+    return 1;
+}
+
+void* thread_connect() {
+    int listenfd, connfd;
+
+    listenfd = create_conn(10023);
+    if (listenfd <= 0) {
+        perror(""create_conn"");
+        exit(EXIT_FAILURE);
+    }
+
+    memset(clients, 0, sizeof(clients));
+
+    int epollfd = epoll_create(101);
+    if (epollfd == -1) {
+        perror(""epoll_create"");
+        exit(EXIT_FAILURE);
+    }
+
+    struct epoll_event ev, events[150];
+    ev.events = EPOLLIN;
+    ev.data.fd = listenfd;
+    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {
+        perror(""epoll_ctl"");
+        exit(EXIT_FAILURE);
+    }
+
+    for (;;) {
+        int nfds = epoll_wait(epollfd, events, 150, -1);
+        if (nfds == -1) {
+            perror(""epoll_wait"");
+            exit(EXIT_FAILURE);
+        }
+
+        for (int i = 0; i < nfds; ++i) {
+            int currfd = events[i].data.fd;
+            if (currfd == listenfd) {
+                int conn_sock = accept(listenfd, NULL, NULL);
+                if (conn_sock == -1) {
+                    perror(""accept"");
+                    continue;
+                }
+
+                int saved = 0;
+                pthread_mutex_lock(&mut);
+                for (int n = 0; n < max_clients; ++n) {
+                    if (clients[n] == 0) {
+                        clients[n] = conn_sock;
+                        saved = 1;
+                        break;
+                    }
+                }
+                pthread_mutex_unlock(&mut);
+
+                if (saved == 0) {
+                    close(conn_sock);
+                    continue;
+                }
+
+                setnonblocking(conn_sock);
+                ev.events = EPOLLIN | EPOLLET;
+                ev.data.fd = conn_sock;
+                if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {
+                    perror(""epoll_ctl"");
+                    exit(EXIT_FAILURE);
+                }
+            } else {
+                char str[50];
+                int n = read(currfd, str, sizeof(str));
+                if (n <= 0) {
+                    pthread_mutex_lock(&mut);
+                    for (int j = 0; j < max_clients; ++j) {
+                        if (clients[j] == currfd) {
+                            clients[j] = 0;
+                            break;
+                        }
+                    }
+                    pthread_mutex_unlock(&mut);
+                    close(currfd);
+                    epoll_ctl(epollfd, EPOLL_CTL_DEL, currfd, NULL);
+                } else {
+                    pthread_mutex_lock(&mut);
+                    strncpy(msg, str, n);
+                    pthread_mutex_unlock(&mut);
+                }
+            }
+        }
+    }
+}
+
+void* thread_proc() {
+    while (1) {
+        pthread_mutex_lock(&mut);
+        int len = strlen(msg);
+        if (len > 0) {
+            for (int i = 0; i < max_clients; ++i) {
+                if (clients[i] > 0) {
+                    write(clients[i], msg, len);
+                }
+            }
+            memset(msg, 0, sizeof(msg));
+        }
+        pthread_mutex_unlock(&mut);
+        usleep(200);
+    }
+}
+
+void* thread_route() {
+    while (1) {
+        pthread_mutex_lock(&mut);
+        if (strlen(msg) > 0) {
+            printf(""msg: %s\\n"", msg);
+        }
+        pthread_mutex_unlock(&mut);
+        usleep(200000);
+    }
+}
+
+int thread_create() {
+    if (pthread_create(&thread[0], NULL, thread_connect, NULL) != 0) {
+        perror(""pthread_create"");
+        return -1;
+    }
+
+    if (pthread_create(&thread[1], NULL, thread_proc, NULL) != 0) {
+        perror(""pthread_create"");
+        return -1;
+    }
+
+    if (pthread_create(&thread[3], NULL, thread_route, NULL) != 0) {
+        perror(""pthread_create"");
+        return -1;
+    }
+
+    return 0;
+}
+
+void thread_wait() {
+    for (int i = 0; i < 3; ++i) {
+        if (thread[i] != 0) {
+            pthread_join(thread[i], NULL);
+            printf(""Thread %d ended\\n"", i);
+        }
+    }
+}
+
+int create_conn(int port) {
+    struct sockaddr_in servaddr;
+    int listenfd;
+
+    listenfd = socket(AF_INET, SOCK_STREAM, 0);
+    if (listenfd < 0) {
+        perror(""socket"");
+        return -1;
+    }
+
+    memset(&servaddr, 0, sizeof(servaddr));
+    servaddr.sin_family = AF_INET;
+    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+    servaddr.sin_port = htons(port);
+
+    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
+        perror(""bind"");
+        return -1;
+    }
+    if (listen(listenfd, LISTEN_BACKLOG) == -1) {
+        perror(""listen"");
+        return -1;
+    }
+
+    return listenfd;
+}
+
+int main(int argc, char** argv) {
+    pthread_mutex_init(&mut, NULL);
+    if (thread_create() != 0) {
+        printf(""Error creating threads\\n"");
+        exit(EXIT_FAILURE);
+    }
+    thread_wait();
+
+    printf(""Server main thread ended\\n"");
+
+    return 0;
+}
+
+",0
+"#include <pthread.h>
+#include <unistd.h>
+#include <stdio.h>
+#include<math.h>
+int tickets = 20;
+pthread_mutex_t mutex;
+
+void *mythread1(void)
+{
+    while (1)
+    {
+
+        if (tickets > 0)
+        {
+            usleep(1000);
+            printf(""ticketse1 sells ticket:%d\\n"", tickets--);
+        }
+        else
+        {
+
+            break;
+        }
+        sleep(1);
+    }
+    return (void *)0;
+}
+void *mythread2(void)
+{
+    while (1)
+    {
+
+        if (tickets > 0)
+        {
+            usleep(1000);
+            printf(""ticketse2 sells ticket:%d\\n"", tickets--);
+ 
+        }
+        else
+        {
+  
+            break;
+        }
+        sleep(1);
+    }
+    return (void *)0;
+}
+
+int main(int argc, const char *argv[])
+{
+    //int i = 0;
+    int ret = 0;
+    pthread_t id1, id2;
+
+    ret = pthread_create(&id1, NULL, (void *)mythread1, NULL);
+    if (ret)
+    {
+        printf(""Create pthread error!\\n"");
+        return 1;
+    }
+
+    ret = pthread_create(&id2, NULL, (void *)mythread2, NULL);
+    if (ret)
+    {
+        printf(""Create pthread error!\\n"");
+        return 1;
+    }
+
+    pthread_join(id1, NULL);
+    pthread_join(id2, NULL);
+
+    return 0;
+}
+",1
+"#include <stdio.h>
+#include <pthread.h>
+#include <unistd.h>
+
+pthread_mutex_t m;
+
+void *func(void *p) {
+    int *source = (int *)p;
+
+    for (int i = 0; i < 10; i++) {
+        pthread_mutex_lock(&m);
+        int t = *(source + i);
+        printf(""t = %d\\n"", t);
+        pthread_mutex_unlock(&m);
+
+        int j;
+        for (j = i; j > 0 && t < source[j - 1]; j--) {
+            source[j] = source[j - 1];
+        }
+        source[j] = t;
+
+        usleep(100);
+    }
+
+    return NULL;
+}
+
+int main() {
+    int a[10];
+    pthread_t id;
+
+
+    pthread_mutex_init(&m, NULL);
+    pthread_mutex_lock(&m);
+
+    
+    int success = pthread_create(&id, NULL, func, a);
+    if (success != 0) {
+        perror(""pthread_create"");
+        return -1;
+    }
+
+    for (int i = 0; i < 10; i++) {
+        printf(""请输入第%d个数据: "", i + 1);
+        scanf(""%d"", &a[i]);
+
+        pthread_mutex_unlock(&m);
+        usleep(100);
+        pthread_mutex_lock(&m);
+    }
+
+    pthread_mutex_unlock(&m);
+
+   
+    pthread_join(id, NULL);
+
+
+    printf(""Sorted array: "");
+    for (int i = 0; i < 10; i++) {
+        printf(""%d "", a[i]);
+    }
+    printf(""\\n"");
+
+
+    pthread_mutex_destroy(&m);
+    return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+enum {
+    QUEUE_BUF_SIZE = 100000,
+};
+
+typedef struct vector_s {
+    int size;
+    int tail;
+    void **buf;
+} vector_t;
+
+typedef struct queue_cycl_s {
+    int front;
+    int tail;
+    int max_size;
+    void **cyclic_buf;
+} queue_cycl_t;
+
+vector_t *vector_init(int size) {
+    vector_t *tmp = (vector_t *)calloc(1, sizeof(vector_t));
+    if (tmp == NULL) {
+        fprintf(stderr, ""vector_init error\\n"");
+        exit(1);
+    }
+
+    tmp->buf = (void **)calloc(size, sizeof(void *));
+    if (tmp->buf == NULL) {
+        fprintf(stderr, ""vector_init error\\n"");
+        free(tmp);
+        exit(1);
+    }
+
+    tmp->size = size;
+    tmp->tail = 0;
+
+    return tmp;
+}
+
+int vector_push_back(vector_t *v, void *data) {
+    if (v->tail == v->size)
+        return 0;
+
+    v->buf[v->tail++] = data;
+
+    return 1;
+}
+
+void *vector_pop_back(vector_t *v) {
+    return (v->tail == 0) ? NULL : v->buf[--(v->tail)];
+}
+
+void vector_delete(vector_t *v) {
+    free(v->buf);
+    free(v);
+}
+
+queue_cycl_t *queue_init() {
+    queue_cycl_t *tmp = (queue_cycl_t *)calloc(1, sizeof(queue_cycl_t));
+    if (tmp == NULL) {
+        fprintf(stderr, ""queue_init error\\n"");
+        exit(1);
+    }
+
+    tmp->max_size = QUEUE_BUF_SIZE + 1;
+    tmp->cyclic_buf = (void **)calloc(tmp->max_size, sizeof(void *));
+    if (tmp->cyclic_buf == NULL) {
+        fprintf(stderr, ""queue_init error\\n"");
+        free(tmp);
+        exit(1);
+    }
+
+    return tmp;
+}
+
+int queue_size(queue_cycl_t *q) {
+    return (q->tail >= q->front) ? (q->tail - q->front) : (q->max_size - q->front + q->tail);
+}
+
+int queue_is_full(queue_cycl_t *q) {
+    return ((q->tail + 1) % q->max_size == q->front);
+}
+
+int queue_is_empty(queue_cycl_t *q) {
+    return (q->front == q->tail);
+}
+
+int queue_enqueue(queue_cycl_t *q, void *data) {
+    if (queue_is_full(q))
+        return 0;
+
+    q->cyclic_buf[q->tail] = data;
+    q->tail = (q->tail + 1) % q->max_size;
+
+    return 1;
+}
+
+void *queue_dequeue(queue_cycl_t *q) {
+    if (queue_is_empty(q))
+        return NULL;
+    void *tmp = q->cyclic_buf[q->front];
+    q->cyclic_buf[q->front] = NULL;
+    q->front = (q->front + 1) % q->max_size;
+
+    return tmp;
+}
+
+vector_t *queue_dequeueall(queue_cycl_t *q) {
+    int s = queue_size(q);
+    vector_t *tmp = vector_init(s);
+    void *data = NULL;
+
+    while ((data = queue_dequeue(q)) != NULL) {
+        if (!vector_push_back(tmp, data)) {
+            queue_enqueue(q, data);
+            fprintf(stderr, ""queue_dequeueall error\\n"");
+            exit(1);
+        }
+    }
+
+    return tmp;
+}
+
+void queue_delete(queue_cycl_t *q) {
+    free(q->cyclic_buf);
+    free(q);
+}
+
+typedef struct actor_s {
+    pthread_t thread;
+    pthread_mutex_t m;
+    pthread_cond_t cond;
+    queue_cycl_t *q;
+} actor_t;
+
+void actor_send_to(actor_t *a, void *msg) {
+
+    queue_enqueue(a->q, msg);
+    pthread_cond_signal(&a->cond);
+}
+
+void *actor_runner(void *arg) {
+    actor_t *iam = (actor_t *)arg;
+    int buf[50] = {0};
+
+    while (1) {
+
+        while (queue_is_empty(iam->q)) {
+            pthread_cond_wait(&iam->cond, &iam->m);
+        }
+        vector_t *v = queue_dequeueall(iam->q);
+
+
+        int *data = NULL, exit_flag = 0;
+        while ((data = vector_pop_back(v)) != NULL) {
+            if (*data == -1) {
+                exit_flag = 1;
+            } else {
+                buf[*data]++;
+            }
+            free(data);
+        }
+        vector_delete(v);
+        if (exit_flag) break;
+    }
+
+    for (int i = 0; i < 50; i++) {
+        if (buf[i] != n_senders) {
+            fprintf(stderr, ""ERROR!!!!!!!!\\n"");
+        }
+    }
+
+    return NULL;
+}
+
+actor_t *actor_init() {
+    actor_t *tmp = (actor_t *)calloc(1, sizeof(actor_t));
+    if (tmp == NULL) {
+        fprintf(stderr, ""actor_init error\\n"");
+        exit(1);
+    }
+
+    pthread_mutex_init(&tmp->m, NULL);
+    pthread_cond_init(&tmp->cond, NULL);
+    tmp->q = queue_init();
+    pthread_create(&tmp->thread, NULL, actor_runner, tmp);
+
+    return tmp;
+}
+
+void actor_finalize(actor_t *a) {
+    pthread_join(a->thread, NULL);
+    queue_delete(a->q);
+    pthread_mutex_destroy(&a->m);
+    pthread_cond_destroy(&a->cond);
+    free(a);
+}
+
+void *sender(void *arg) {
+    actor_t *receiver = (actor_t *)arg;
+    int *msg = NULL;
+
+    for (int i = 0; i < 50; i++) {
+        msg = (int *)calloc(1, sizeof(int));
+        if (msg == NULL) {
+            fprintf(stderr, ""Memory allocation failed\\n"");
+            exit(1);
+        }
+        *msg = i;
+        actor_send_to(receiver, msg);
+    }
+
+    return NULL;
+}
+
+int main(int argc, char **argv) {
+    if (argc != 2) {
+        fprintf(stderr, ""Usage: %s <number_of_senders>\\n"", argv[0]);
+        exit(1);
+    }
+
+    n_senders = atoi(argv[1]);
+    pthread_t *senders_id = (pthread_t *)calloc(n_senders, sizeof(pthread_t));
+    if (senders_id == NULL) {
+        fprintf(stderr, ""Memory allocation failed\\n"");
+        exit(1);
+    }
+
+    actor_t *actor = actor_init();
+    for (int i = 0; i < n_senders; i++) {
+        pthread_create(&senders_id[i], NULL, sender, actor);
+    }
+
+    for (int i = 0; i < n_senders; i++) {
+        pthread_join(senders_id[i], NULL);
+    }
+
+    int *msg_ext = (int *)calloc(1, sizeof(int));
+    *msg_ext = -1;
+    actor_send_to(actor, msg_ext);
+    actor_finalize(actor);
+
+    free(senders_id);
+    return 0;
+}
+
+",1
+"#include <stdio.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <string.h>
+
+#define DATA_MAX 5
+#define PRO_INIT_VAL (DATA_MAX / 2)
+#define CON_INIT_VAL (DATA_MAX - PRO_INIT_VAL)
+static int data;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t mutex;
+static sem_t sem_pro;
+static sem_t sem_con;
+
+static void *pro_handler(void *arg)
+{
+	ssize_t i = 100;
+
+	for (; i > 0; --i) {
+
+		pthread_mutex_lock(&mutex);
+
+		++data;
+		printf(""producter: data = %d\\n"", data);
+
+		pthread_mutex_unlock(&mutex);
+
+		pthread_cond_signal(&cond);
+		usleep(100000);
+	}
+
+}
+
+static void *con_handler(void *arg)
+{
+	ssize_t i = 100;
+
+
+
+	for (; i > 0; --i) {
+
+		pthread_mutex_lock(&mutex);
+		while (data == 0) {
+			pthread_cond_wait(&cond, &mutex);
+		}
+		while (data > 0) {
+			--data;
+			printf(""consumer: data = %d\\n"", data);
+		}
+		pthread_mutex_unlock(&mutex);
+
+		sleep(1);
+	}
+}
+
+int main()
+{
+	pthread_mutex_init(&mutex, NULL);
+
+	sem_init(&sem_pro, 0, PRO_INIT_VAL);
+	sem_init(&sem_con, 0, CON_INIT_VAL);
+
+	data = CON_INIT_VAL;
+
+	pthread_t pro_id, con_id;
+	
+	int pro_ret = 0;
+	if (pro_ret = pthread_create(&pro_id, NULL, pro_handler, NULL)) {
+		fprintf(stderr, ""pthread_create producter: %s"", strerror(pro_ret));
+		goto err_create_producter;
+	}
+
+	int con_ret = 0;
+	if (con_ret = pthread_create(&con_id, NULL, con_handler, NULL)) {
+		fprintf(stderr, ""pthread_create consumer: %s"", strerror(con_ret));
+		goto err_create_consumer;
+	}
+#if 0
+	sleep(3);
+	if (pthread_cancel(con_id)) {
+		fprintf(stderr, ""error cancel\\n"");
+	}
+#endif
+	pthread_join(pro_id, NULL);
+	pthread_join(con_id, NULL);
+
+	sem_destroy(&sem_con);
+	sem_destroy(&sem_pro);
+	pthread_mutex_destroy(&mutex);
+	return 0;
+
+
+err_create_consumer:
+	pthread_join(pro_id, NULL);
+err_create_producter:
+	sem_destroy(&sem_con);
+	sem_destroy(&sem_pro);
+	pthread_mutex_destroy(&mutex);
+	return -1;
+}
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <errno.h>
+
+enum mode {
+ MODE_MB,
+ MODE_MEMBARRIER,
+ MODE_COMPILER_BARRIER,
+ MODE_MEMBARRIER_MISSING_REGISTER,
+};
+
+enum mode mode;
+
+struct map_test {
+ int x, y;
+ int ref;
+ int r2, r4;
+ int r2_ready, r4_ready;
+ int killed;
+ pthread_mutex_t lock;
+};
+
+static void check_parent_regs(struct map_test *map_test, int r2)
+{
+
+ if (map_test->r4_ready) {
+  if (r2 == 0 && map_test->r4 == 0) {
+   fprintf(stderr, ""Error detected!\\n"");
+   CMM_STORE_SHARED(map_test->killed, 1);
+   abort();
+  }
+  map_test->r4_ready = 0;
+  map_test->x = 0;
+  map_test->y = 0;
+ } else {
+  map_test->r2 = r2;
+  map_test->r2_ready = 1;
+ }
+}
+
+static void check_child_regs(struct map_test *map_test, int r4)
+{
+
+ if (map_test->r2_ready) {
+  if (r4 == 0 && map_test->r2 == 0) {
+   fprintf(stderr, ""Error detected!\\n"");
+   CMM_STORE_SHARED(map_test->killed, 1);
+   abort();
+  }
+  map_test->r2_ready = 0;
+  map_test->x = 0;
+  map_test->y = 0;
+ } else {
+  map_test->r4 = r4;
+  map_test->r4_ready = 1;
+ }
+
+}
+
+static void loop_parent(struct map_test *map_test)
+{
+ int i, r2;
+
+ for (i = 0; i < 100000000; i++) {
+  uatomic_inc(&map_test->ref);
+  while (uatomic_read(&map_test->ref) < 2 * (i + 1)) {
+   if (map_test->killed)
+    abort();
+   caa_cpu_relax();
+  }
+  CMM_STORE_SHARED(map_test->x, 1);
+  switch (mode) {
+  case MODE_MB:
+   cmm_smp_mb();
+   break;
+  case MODE_MEMBARRIER:
+  case MODE_MEMBARRIER_MISSING_REGISTER:
+   if (-ENOSYS) {
+    perror(""membarrier"");
+    CMM_STORE_SHARED(map_test->killed, 1);
+    abort();
+   }
+   break;
+  case MODE_COMPILER_BARRIER:
+   cmm_barrier();
+   break;
+  }
+  r2 = CMM_LOAD_SHARED(map_test->y);
+  check_parent_regs(map_test, r2);
+ }
+}
+
+static void loop_child(struct map_test *map_test)
+{
+ int i, r4;
+
+ switch (mode) {
+ case MODE_MEMBARRIER:
+  if (-ENOSYS) {
+   perror(""membarrier"");
+   CMM_STORE_SHARED(map_test->killed, 1);
+   abort();
+  }
+  break;
+ default:
+  break;
+ }
+ for (i = 0; i < 100000000; i++) {
+  uatomic_inc(&map_test->ref);
+  while (uatomic_read(&map_test->ref) < 2 * (i + 1)) {
+   if (map_test->killed)
+    abort();
+   caa_cpu_relax();
+  }
+
+  CMM_STORE_SHARED(map_test->y, 1);
+  switch (mode) {
+  case MODE_MB:
+   cmm_smp_mb();
+   break;
+  case MODE_MEMBARRIER:
+  case MODE_MEMBARRIER_MISSING_REGISTER:
+
+   cmm_barrier();
+   break;
+  case MODE_COMPILER_BARRIER:
+   cmm_barrier();
+   break;
+  }
+  r4 = CMM_LOAD_SHARED(map_test->x);
+  check_child_regs(map_test, r4);
+ }
+}
+
+void print_arg_error(void)
+{
+ fprintf(stderr, ""Please specify test mode: <m>: paired mb, <s>: sys-membarrier, <c>: compiler barrier (error), <n>: sys-membarrier with missing registration (error).\\n"");
+}
+
+int main(int argc, char **argv)
+{
+ char namebuf[PATH_MAX];
+ pid_t pid;
+ int fd, ret = 0;
+ void *buf;
+ struct map_test *map_test;
+ pthread_mutexattr_t attr;
+
+ if (argc < 2) {
+  print_arg_error();
+  return -1;
+ }
+ if (!strcmp(argv[1], ""-m"")) {
+  mode = MODE_MB;
+ } else if (!strcmp(argv[1], ""-s"")) {
+  mode = MODE_MEMBARRIER;
+ } else if (!strcmp(argv[1], ""-c"")) {
+  mode = MODE_COMPILER_BARRIER;
+ } else if (!strcmp(argv[1], ""-n"")) {
+  mode = MODE_MEMBARRIER_MISSING_REGISTER;
+ } else {
+  print_arg_error();
+  return -1;
+ }
+
+ buf = mmap(0, 4096, PROT_READ | PROT_WRITE,
+   MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+ if (buf == MAP_FAILED) {
+  perror(""mmap"");
+  ret = -1;
+  goto end;
+ }
+ map_test = (struct map_test *)buf;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_setpshared(&attr, 1);
+ pthread_mutex_init(&map_test->lock, &attr);
+ pid = fork();
+ if (pid < 0) {
+  perror(""fork"");
+  ret = -1;
+  goto unmap;
+ }
+ if (!pid) {
+
+  loop_child(map_test);
+  return 0;
+ }
+
+ loop_parent(map_test);
+ pid = waitpid(pid, 0, 0);
+ if (pid < 0) {
+  perror(""waitpid"");
+  ret = -1;
+ }
+unmap:
+ pthread_mutex_destroy(&map_test->lock);
+ pthread_mutexattr_destroy(&attr);
+ if (munmap(buf, 4096)) {
+  perror(""munmap"");
+  ret = -1;
+ }
+end:
+ return ret;
+}
+",1
+"#include <stdio.h>
+#include <pthread.h>
+
+
+int sum, max, min;
+
+int arr[500];
+
+pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER, mut2 = PTHREAD_MUTEX_INITIALIZER, mut3 = PTHREAD_MUTEX_INITIALIZER;
+
+typedef struct params
+{
+    int sindex;
+    int eindex;
+}params_t;
+
+
+void *func(void * args)
+{
+
+    params_t *p = (params_t *)args;
+
+    int i, localSum = 0,localMax = 0,localMin = 0;
+
+    for(i = p->sindex; i <= p->eindex; i++)
+    {
+        localSum = localSum + arr[i];
+
+        if(arr[i] > localMax)
+        localMax = arr[i];
+
+        if(arr[i] < localMin)
+        localMin = arr[i];
+    }
+
+   
+    pthread_mutex_lock(&mut1);
+    sum = sum + localSum;
+    pthread_mutex_unlock(&mut1);
+
+    pthread_mutex_lock(&mut2);
+    if(localMin < min)
+    min = localMin;
+    pthread_mutex_unlock(&mut2);
+
+    pthread_mutex_lock(&mut3);
+    if(localMax > max)
+    max = localMax;
+    pthread_mutex_unlock(&mut3);
+
+}
+
+int main()
+{
+    int i;
+    pthread_t tid[5];
+
+    params_t p[5];
+
+    int t1 = 0;
+
+
+    for(i = 0; i < 500; i++)
+    {
+        if(i == 203)
+        arr[i] = 1000;
+        else if(i == 440)
+        arr[i] = -1;
+        else
+        arr[i] = i;
+    }
+
+
+    for(i = 0; i < 5; i++)
+    {
+        p[i].sindex = t1;
+        p[i].eindex = t1 + 99;
+        t1 = t1 + 1 + 99;
+    }
+
+
+    for(i = 0; i < 5; i++)
+    {
+        pthread_create(&tid[i],NULL,func,&p[i]);
+    }
+
+
+    for(i = 0; i < 5; i++)
+    {
+        pthread_join(tid[i],NULL);
+    }
+
+    printf(""Sum of all array elements: %d\\n"",sum);
+    printf(""Greatest number of all: %d\\n"",max);
+    printf(""Lowest number of all: %d\\n"",min);
+
+    return 0;
+}
+",0
+"#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NUM_THREADS  4
+#define TOTAL_COUNT 10
+#define COUNT_LIMIT 12
+
+int count = 0;
+pthread_mutex_t count_mutex;
+pthread_cond_t count_threshold_cv;
+
+void *inc_count(void *t)
+{
+    int i;
+    long my_id = (long)t;
+
+    for (i = 0; i < TOTAL_COUNT; i++) {
+
+        count++;
+
+        if (count == COUNT_LIMIT) {
+            printf(""inc_count(): thread %ld, count = %d  Threshold reached. "",
+                my_id, count);
+            pthread_cond_signal(&count_threshold_cv);
+            printf(""Just sent signal.\\n"");
+        }
+        printf(""inc_count(): thread %ld, count = %d, unlocking mutex\\n"",
+            my_id, count);
+
+        /* Do some work so threads can alternate on mutex lock */
+        sleep(1);
+    }
+    pthread_exit(NULL);
+}
+
+void *watch_count(void *t)
+{
+    long my_id = (long)t;
+
+    printf(""watch_count(): thread %ld\\n"", my_id);
+
+
+    while (count < COUNT_LIMIT) {
+        printf(""watch_count(): thread %ld Count= %d. Going into wait...\\n"", my_id, count);
+        pthread_cond_wait(&count_threshold_cv, &count_mutex);
+        printf(""watch_count(): thread %ld Condition signal received. Count= %d\\n"", my_id, count);
+    }
+    printf(""watch_count(): thread %ld Updating the value of count...\\n"", my_id);
+    count += 125;
+    printf(""watch_count(): thread %ld count now = %d.\\n"", my_id, count);
+    printf(""watch_count(): thread %ld Unlocking mutex.\\n"", my_id);
+    pthread_exit(NULL);
+}
+
+int main(int argc, char *argv[])
+{
+    int i;
+    long t1=1, t2=2, t3=3, t4=4;
+    pthread_t threads[NUM_THREADS];
+    pthread_attr_t attr;
+
+    /* Initialize mutex and condition variable objects */
+    pthread_mutex_init(&count_mutex, NULL);
+    pthread_cond_init(&count_threshold_cv, NULL);
+
+    /* For portability, explicitly create threads in a joinable state */
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
+    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
+    pthread_create(&threads[2], &attr, inc_count, (void *)t3);
+    pthread_create(&threads[3], &attr, inc_count, (void *)t4);
+
+    /* Wait for all threads to complete */
+    for (i = 0; i < NUM_THREADS; i++) {
+        pthread_join(threads[i], NULL);
+    }
+    printf (""main(): waited and joined with %d threads. Final value of count = %d. Done.\\n"",
+        NUM_THREADS, count);
+
+    /* Clean up and exit */
+    pthread_attr_destroy(&attr);
+    pthread_mutex_destroy(&count_mutex);
+    pthread_cond_destroy(&count_threshold_cv);
+    pthread_exit(NULL);
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+void *thread_function(void *arg);
+pthread_mutex_t work_mutex;
+pthread_cond_t work_cond;
+
+#define WORK_SIZE 1024
+char work_area[WORK_SIZE];
+int time_to_exit = 0;
+
+int main()
+{
+    int res;
+    pthread_t a_thread;
+    void *thread_result;
+
+    res = pthread_mutex_init(&work_mutex, NULL);
+    if (res != 0) {
+        perror(""Mutex initialization failed"");
+        exit(EXIT_FAILURE);
+    }
+
+    res = pthread_cond_init(&work_cond, NULL);
+    if (res != 0) {
+        perror(""Condition variable initialization failed"");
+        exit(EXIT_FAILURE);
+    }
+
+    res = pthread_create(&a_thread, NULL, thread_function, NULL);
+    if (res != 0) {
+        perror(""Thread creation failed"");
+        exit(EXIT_FAILURE);
+    }
+
+    pthread_mutex_lock(&work_mutex);
+    printf(""Input some text, enter 'end' to finish:\\n"");
+    while (!time_to_exit) {
+        fgets(work_area, WORK_SIZE, stdin);
+
+     
+        pthread_cond_signal(&work_cond);
+        pthread_mutex_unlock(&work_mutex);
+
+        pthread_mutex_lock(&work_mutex);
+        while (work_area[0] != '\\0') {
+            pthread_cond_wait(&work_cond, &work_mutex);
+        }
+    }
+
+    pthread_mutex_unlock(&work_mutex);
+    printf(""Waiting for thread to finish...\\n"");
+
+    res = pthread_join(a_thread, &thread_result);
+    if (res != 0) {
+        perror(""pthread_join failed"");
+        exit(EXIT_FAILURE);
+    }
+
+    printf(""Thread joined\\n"");
+
+    pthread_mutex_destroy(&work_mutex);
+    pthread_cond_destroy(&work_cond);
+
+    exit(EXIT_SUCCESS);
+}
+
+void *thread_function(void *arg)
+{
+    sleep(1);
+    pthread_mutex_lock(&work_mutex);
+    while (strncmp(""end"", work_area, 3) != 0) {
+        printf(""You input %d characters\\n"", (int)(strlen(work_area) - 1));
+        work_area[0] = '\\0';
+
+     
+        pthread_cond_signal(&work_cond);
+        pthread_cond_wait(&work_cond, &work_mutex);
+    }
+
+    time_to_exit = 1;
+    pthread_cond_signal(&work_cond);
+    pthread_mutex_unlock(&work_mutex);
+    pthread_exit(0);
+}
+
+",0
+"#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+
+#define FILE_SIZE 671088640  // 800 MB
+#define BUFFER_SIZE 8
+
+int thread_count = 0;
+int server_file_des, bytes_read;
+unsigned long long int block_size = 0, file_pos = 0, total_bytes = 0;
+pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
+
+void *receive_data(void *thread_id) {
+    unsigned long long int start_pos, end_pos;
+    unsigned long long int local_bytes = 0;
+    char buffer[BUFFER_SIZE];
+
+
+    start_pos = file_pos;
+    file_pos += block_size;
+
+
+    end_pos = start_pos + block_size;
+
+    struct sockaddr_in client_addr;
+    socklen_t addr_len = sizeof(client_addr);
+
+    while (start_pos < end_pos) {
+        bytes_read = recvfrom(server_file_des, buffer, BUFFER_SIZE, 0, (struct sockaddr*)&client_addr, &addr_len);
+        
+        if (bytes_read > 0) {
+            local_bytes += bytes_read;
+            start_pos += bytes_read;
+            printf(""Thread %ld transferred %llu bytes (total transferred: %llu bytes)\\n"", (long)thread_id, local_bytes, start_pos);
+        } else {
+            perror(""recvfrom"");
+            break;
+        }
+    }
+
+
+    total_bytes += local_bytes;
+
+
+    pthread_exit(NULL);
+}
+
+int main() {
+    int ch;
+    printf(""Perform Network Benchmarking on\\n1. 1 Thread\\n2. 2 Threads\\n3. 4 Threads\\n4. 8 Threads\\n"");
+    scanf(""%d"", &ch);
+
+    if (ch == 1 || ch == 2 || ch == 3 || ch == 4) {
+        thread_count = (ch == 4) ? 8 : ch == 3 ? 4 : ch;
+        printf(""Number of Threads: %d\\n"", thread_count);
+    } else {
+        printf(""Invalid Choice\\nProgram terminated\\n"");
+        return 0;
+    }
+
+    struct sockaddr_in address;
+    int addrlen = sizeof(address);
+
+    // Create UDP socket
+    if ((server_file_des = socket(AF_INET, SOCK_DGRAM, 0)) == 0) {
+        perror(""Socket failed"");
+        exit(EXIT_FAILURE);
+    }
+
+    // Setup server address
+    address.sin_family = AF_INET;
+    address.sin_addr.s_addr = INADDR_ANY;
+    address.sin_port = htons(5000);
+
+    // Bind the socket
+    if (bind(server_file_des, (struct sockaddr *)&address, sizeof(address)) < 0) {
+        perror(""Bind failed"");
+        exit(EXIT_FAILURE);
+    }
+
+ 
+    block_size = FILE_SIZE / thread_count;
+
+    pthread_t threads[thread_count];
+    for (long j = 0; j < thread_count; j++) {
+        pthread_create(&threads[j], NULL, receive_data, (void*)j);  // Thread Creation
+    }
+
+    for (int k = 0; k < thread_count; k++) {
+        pthread_join(threads[k], NULL);
+    }
+
+    printf(""Total bytes transferred: %llu bytes\\n"", total_bytes);
+
+    close(server_file_des);
+    return 0;
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+#include <poll.h>
+#include <errno.h>
+
+
+static struct dlm_lksb lksb;
+static int use_threads = 0;
+static int quiet = 0;
+
+static pthread_cond_t cond;
+static pthread_mutex_t mutex;
+
+static int ast_called = 0;
+
+static int modetonum(char *modestr)
+{
+    int mode = LKM_EXMODE;
+
+    if (strncasecmp(modestr, ""NL"", 2) == 0) mode = LKM_NLMODE;
+    if (strncasecmp(modestr, ""CR"", 2) == 0) mode = LKM_CRMODE;
+    if (strncasecmp(modestr, ""CW"", 2) == 0) mode = LKM_CWMODE;
+    if (strncasecmp(modestr, ""PR"", 2) == 0) mode = LKM_PRMODE;
+    if (strncasecmp(modestr, ""PW"", 2) == 0) mode = LKM_PWMODE;
+    if (strncasecmp(modestr, ""EX"", 2) == 0) mode = LKM_EXMODE;
+
+    return mode;
+}
+
+static char *numtomode(int mode)
+{
+    switch (mode)
+    {
+    case LKM_NLMODE: return ""NL"";
+    case LKM_CRMODE: return ""CR"";
+    case LKM_CWMODE: return ""CW"";
+    case LKM_PRMODE: return ""PR"";
+    case LKM_PWMODE: return ""PW"";
+    case LKM_EXMODE: return ""EX"";
+    default: return ""??"";
+    }
+}
+
+static void usage(char *prog, FILE *file)
+{
+    fprintf(file, ""Usage:\\n"");
+    fprintf(file, ""%s [mcnpquhV] <lockname>\\n"", prog);
+    fprintf(file, ""\\n"");
+    fprintf(file, ""   -V         Show version of dlmtest\\n"");
+    fprintf(file, ""   -h         Show this help information\\n"");
+    fprintf(file, ""   -m <mode>  lock mode (default EX)\\n"");
+    fprintf(file, ""   -c <mode>  mode to convert to (default none)\\n"");
+    fprintf(file, ""   -n         don't block\\n"");
+    fprintf(file, ""   -p         Use pthreads\\n"");
+    fprintf(file, ""   -u         Don't unlock\\n"");
+    fprintf(file, ""   -C         Crash after lock\\n"");
+    fprintf(file, ""   -q         Quiet\\n"");
+    fprintf(file, ""   -u         Don't unlock explicitly\\n"");
+    fprintf(file, ""\\n"");
+}
+
+static void ast_routine(void *arg)
+{
+    struct dlm_lksb *lksb = arg;
+
+    if (!quiet)
+        printf(""ast called, status = %d, lkid=%x\\n"", lksb->sb_status, lksb->sb_lkid);
+
+    pthread_mutex_lock(&mutex);
+    ast_called = 1;
+    pthread_cond_signal(&cond);
+    pthread_mutex_unlock(&mutex);
+}
+
+static void bast_routine(void *arg)
+{
+    struct dlm_lksb *lksb = arg;
+
+    if (!quiet)
+        printf(""\\nblocking ast called, status = %d, lkid=%x\\n"", lksb->sb_status, lksb->sb_lkid);
+}
+
+static int poll_for_ast()
+{
+    struct pollfd pfd;
+
+    pfd.fd = dlm_get_fd();
+    pfd.events = POLLIN;
+    
+    pthread_mutex_lock(&mutex);
+    while (!ast_called)
+    {
+        pthread_mutex_unlock(&mutex);
+        if (poll(&pfd, 1, -1) < 0)
+        {
+            perror(""poll"");
+            return -1;
+        }
+        dlm_dispatch(pfd.fd);
+        pthread_mutex_lock(&mutex);
+    }
+    ast_called = 0;
+    pthread_mutex_unlock(&mutex);
+    return 0;
+}
+
+int main(int argc, char *argv[])
+{
+    char *resource = ""LOCK-NAME"";
+    int flags = 0;
+    int delay = 0;
+    int status;
+    int mode = LKM_EXMODE;
+    int convmode = -1;
+    int do_unlock = 1;
+    int do_crash = 0;
+    signed char opt;
+
+    opterr = 0;
+    optind = 0;
+    while ((opt = getopt(argc, argv, ""?m:nqupc:d:CvV"")) != EOF)
+    {
+        switch (opt)
+        {
+        case 'h':
+            usage(argv[0], stdout);
+            exit(0);
+
+        case '?':
+            usage(argv[0], stderr);
+            exit(0);
+
+        case 'm':
+            mode = modetonum(optarg);
+            break;
+
+        case 'c':
+            convmode = modetonum(optarg);
+            break;
+
+        case 'p':
+            use_threads++;
+            break;
+
+        case 'n':
+            flags |= LKF_NOQUEUE;
+            break;
+
+        case 'q':
+            quiet = 1;
+            break;
+
+        case 'u':
+            do_unlock = 0;
+            break;
+
+        case 'C':
+            do_crash = 1;
+            break;
+
+        case 'd':
+            delay = atoi(optarg);
+            break;
+
+        case 'V':
+            printf(""\\nasttest version 0.1\\n\\n"");
+            exit(1);
+            break;
+        }
+    }
+
+    if (argv[optind])
+        resource = argv[optind];
+
+    if (!quiet)
+        fprintf(stderr, ""locking %s %s %s..."", resource,
+                numtomode(mode),
+                (flags & LKF_NOQUEUE ? ""(NOQUEUE)"" : """"));
+
+    fflush(stderr);
+
+    if (use_threads)
+    {
+        pthread_cond_init(&cond, NULL);
+        pthread_mutex_init(&mutex, NULL);
+        pthread_mutex_lock(&mutex);
+        dlm_pthread_init();
+    }
+
+    status = dlm_lock(mode, &lksb, flags, resource, strlen(resource), 0,
+                      ast_routine, &lksb, bast_routine, 0);
+    if (status == -1)
+    {
+        if (!quiet) fprintf(stderr, ""\\n"");
+        perror(""lock"");
+        return -1;
+    }
+    printf(""(lkid=%x)"", lksb.sb_lkid);
+
+    if (do_crash)
+        *(int *)0 = 0xdeadbeef;
+
+    if (use_threads)
+    {
+        pthread_cond_wait(&cond, &mutex);
+        pthread_mutex_unlock(&mutex);
+    }
+    else
+    {
+        poll_for_ast();
+    }
+
+    if (delay)
+        sleep(delay);
+
+    if (!quiet)
+    {
+        fprintf(stderr, ""unlocking %s..."", resource);
+        fflush(stderr);
+    }
+
+    if (do_unlock)
+    {
+        status = dlm_unlock(lksb.sb_lkid, 0, &lksb, &lksb);
+        if (status == -1)
+        {
+            if (!quiet) fprintf(stderr, ""\\n"");
+            perror(""unlock"");
+            return -1;
+        }
+
+        if (use_threads)
+        {
+            pthread_cond_wait(&cond, &mutex);
+            pthread_mutex_unlock(&mutex);
+        }
+        else
+        {
+            poll_for_ast();
+        }
+    }
+
+    return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <unistd.h>
+
+#define THREADS_NUM 3
+
+
+typedef struct List {
+    int value;
+    struct List *next;
+} List;
+
+struct List *lista = NULL;
+
+pthread_mutex_t mutex;
+sem_t sem;
+
+
+void display(struct List *element) {
+    printf(""["");
+    while (element) {
+        printf(""%d"", element->value);
+        if (element->next) {
+            printf("", "");
+        }
+        element = element->next;
+    }
+    printf(""]\\n"");
+}
+
+
+void push_f(int value) {
+    struct List *newElement;
+    struct List *cursor = lista;
+    newElement = (struct List *)malloc(sizeof(struct List));
+    newElement->value = value;
+    newElement->next = NULL;
+
+    if (lista == NULL) {
+        lista = newElement;
+    } else {
+     
+        while (cursor->next) {
+            cursor = cursor->next;
+        }
+        cursor->next = newElement;
+    }
+}
+
+
+int pop_f() {
+    if (lista == NULL) {
+        return -1;
+    }
+
+    struct List *cursor = lista;
+    struct List *prev = NULL;
+
+    while (cursor->next) {
+        prev = cursor;
+        cursor = cursor->next;
+    }
+
+    int return_value = cursor->value;
+
+
+    if (prev == NULL) {
+        free(cursor);
+        lista = NULL;
+    } else {
+        free(cursor);
+        prev->next = NULL;
+    }
+
+    return return_value;
+}
+
+
+void *popThread(void *arg) {
+    while (1) {
+        sem_wait(&sem);
+  
+
+        int val = pop_f();
+        if (val != -1) {
+            printf(""Thread removed: %d\\n"", val);
+        } else {
+            printf(""Thread tried to remove from an empty list.\\n"");
+        }
+        display(lista);
+
+
+        sleep(3);
+    }
+    return NULL;
+}
+
+
+void *pushThread(void *arg) {
+    while (1) {
+        int val = rand() % 100;
+
+
+        push_f(val);
+        printf(""Thread inserted: %d\\n"", val);
+        display(lista);
+
+
+
+        sem_post(&sem);
+
+        sleep(1);
+    }
+    return NULL;
+}
+
+int main() {
+    pthread_t tid[THREADS_NUM];
+    pthread_mutex_init(&mutex, NULL);
+    sem_init(&sem, 0, 0); // Initialize semaphore with 0
+
+    srand(time(NULL));
+
+
+    pthread_create(&tid[0], NULL, pushThread, NULL);
+    pthread_create(&tid[1], NULL, popThread, NULL);
+    pthread_create(&tid[2], NULL, popThread, NULL);
+
+
+    for (int i = 0; i < THREADS_NUM; i++) {
+        pthread_join(tid[i], NULL);
+    }
+
+
+    sem_destroy(&sem);
+    pthread_mutex_destroy(&mutex);
+
+
+    while (lista) {
+        pop_f();
+    }
+
+    return 0;
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <pthread.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <linux/videodev2.h>
+
+int sockfd;
+int cameraFd;
+unsigned char *devconfp;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+
+void sig_handler(int signo) {
+    if (signo == SIGINT) {
+        printf(""SIGINT received, exiting!\\n"");
+        close(sockfd);
+        if (cameraFd >= 0) {
+            close(cameraFd);
+        }
+        exit(0);
+    }
+}
+
+unsigned char *temp;
+ssize_t length;
+
+void get_frame(int cameraFd) {
+    struct v4l2_buffer buf;
+    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buf.memory = V4L2_MEMORY_MMAP;
+
+    if (ioctl(cameraFd, VIDIOC_DQBUF, &buf) == -1) {
+        perror(""VIDIOC_DQBUF"");
+        exit(1);
+    }
+
+    length = buf.bytesused;
+    temp = (unsigned char *)malloc(length);
+    if (!temp) {
+        perror(""malloc"");
+        exit(1);
+    }
+    memcpy(temp, (unsigned char *)buf.m.userptr, length);
+
+    if (ioctl(cameraFd, VIDIOC_QBUF, &buf) == -1) {
+        perror(""VIDIOC_QBUF"");
+        free(temp);
+        exit(1);
+    }
+}
+
+int stop = 0;
+
+void *frame_capture_thread(void *arg) {
+    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    while (!stop) {
+        get_frame(cameraFd);
+        pthread_mutex_lock(&mutex);
+        devconfp = (unsigned char*)malloc(length);
+        if (!devconfp) {
+            perror(""malloc"");
+            pthread_mutex_unlock(&mutex);
+            exit(1);
+        }
+        memcpy(devconfp, temp, length);
+        pthread_mutex_unlock(&mutex);
+        pthread_cond_broadcast(&cond);
+        usleep(1500);
+        free(temp);
+    }
+
+    if (ioctl(cameraFd, VIDIOC_STREAMOFF, &type) == -1) {
+        perror(""VIDIOC_STREAMOFF"");
+        exit(1);
+    }
+    return NULL;
+}
+
+void send_msg(int fd) {
+    ssize_t size;
+    char readbuffer[1024] = {'\\0'};
+    char writebuffer[1024] = {'\\0'};
+    size = read(fd, readbuffer, sizeof(readbuffer) - 1);
+    if (size < 0) {
+        perror(""read"");
+        exit(1);
+    }
+
+    char respbuffer[] = ""HTTP/1.0 200 OK\\r\\nConnection: close\\r\\n""
+                        ""Server: Net-camera-1-0\\r\\nCache-Control: no-store, no-cache, must-revalidate\\r\\n""
+                        ""Pragma: no-cache\\r\\nContent-Type: multipart/x-mixed-replace; boundary=www.briup.com\\r\\n\\r\\n"";
+    if (write(fd, respbuffer, strlen(respbuffer)) != strlen(respbuffer)) {
+        perror(""write"");
+        exit(1);
+    }
+
+    if (strstr(readbuffer, ""snapshot"")) {
+        pthread_mutex_lock(&mutex);
+        if (pthread_cond_wait(&cond, &mutex) != 0) {
+            perror(""pthread_cond_wait"");
+            pthread_mutex_unlock(&mutex);
+            exit(1);
+        }
+
+        sprintf(writebuffer, ""--www.briup.com\\nContent-Type: image/jpeg\\nContent-Length: %zu\\n\\n"", length);
+        write(fd, writebuffer, strlen(writebuffer));
+        write(fd, devconfp, length);
+
+        free(devconfp);
+        pthread_mutex_unlock(&mutex);
+    } else {
+        while (1) {
+            pthread_mutex_lock(&mutex);
+            if (pthread_cond_wait(&cond, &mutex) != 0) {
+                perror(""pthread_cond_wait"");
+                pthread_mutex_unlock(&mutex);
+                exit(1);
+            }
+
+            sprintf(writebuffer, ""--www.briup.com\\nContent-Type: image/jpeg\\nContent-Length: %zu\\n\\n"", length);
+            write(fd, writebuffer, strlen(writebuffer));
+            write(fd, devconfp, length);
+
+            pthread_mutex_unlock(&mutex);
+            sleep(1);
+        }
+    }
+}
+
+void *service_thread(void *arg) {
+    int fd = (intptr_t)arg;
+    send_msg(fd);
+    close(fd);
+    return NULL;
+}
+
+int main(int argc, char *argv[]) {
+    if (argc != 3) {
+        fprintf(stderr, ""Usage: %s <device> <port>\\n"", argv[0]);
+        exit(1);
+    }
+
+    if (signal(SIGINT, sig_handler) == SIG_ERR) {
+        perror(""signal"");
+        exit(1);
+    }
+
+    if ((cameraFd = open(argv[1], O_RDWR)) < 0) {
+        perror(""open"");
+        exit(1);
+    }
+
+    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    if (sockfd < 0) {
+        perror(""socket"");
+        exit(1);
+    }
+
+    struct sockaddr_in saddr = {0};
+    saddr.sin_family = AF_INET;
+    saddr.sin_port = htons(atoi(argv[2]));
+    saddr.sin_addr.s_addr = INADDR_ANY;
+
+    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
+        perror(""bind"");
+        exit(1);
+    }
+
+    if (listen(sockfd, 10) < 0) {
+        perror(""listen"");
+        exit(1);
+    }
+
+    pthread_t capture_thread;
+    if (pthread_create(&capture_thread, NULL, frame_capture_thread, NULL) != 0) {
+        perror(""pthread_create"");
+        exit(1);
+    }
+
+    while (1) {
+        int client_fd = accept(sockfd, NULL, NULL);
+        if (client_fd < 0) {
+            perror(""accept"");
+            continue;
+        }
+
+        pthread_t service;
+        if (pthread_create(&service, NULL, service_thread, (void *)(intptr_t)client_fd) != 0) {
+            perror(""pthread_create"");
+        }
+    }
+
+    return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <time.h>
+#include <math.h>
+
+
+int MAX_NUMBER = 65535;
+int max_m_operations = 200;
+int thread_count = 8;
+int initial_length = 10;
+int seed =18;
+
+double member_fraction = 0.80;
+double insert_fraction = 0.10;
+double delete_fraction = 0.10;
+
+struct node** head_node;
+
+pthread_mutex_t list_mutex;
+
+int max_member_number=0;
+int max_insert_number=0;
+int max_delete_number=0;
+
+struct node {
+  int data;
+  struct node *next;
+};
+
+int Member(int value, struct node* head){
+    struct node* curr=head;
+
+    while(curr!=0 && curr->data < value)
+        curr = curr->next;
+
+    if(curr == 0 || curr->data > value){
+        return 0;
+    }else{
+        return 1;
+    }
+}
+
+int Insert(int value, struct node** head){
+    struct node* curr = *head;
+    struct node* prev = 0;
+    struct node* temp;
+
+    while(curr!=0 && curr-> data < value){
+        prev=curr;
+        curr=curr->next;
+    }
+
+    if(curr==0 || curr->data > value){
+        temp = malloc(sizeof(struct node));
+        temp->data = value;
+        temp->next = curr;
+
+        if(prev==0){
+            *head=temp;
+        }
+        else{
+            prev->next=temp;
+        }
+        return 1;
+    }else{
+        return 0;
+    }
+}
+
+int Delete(int value, struct node** head){
+    struct node* curr= *head;
+    struct node* prev= 0;
+
+    while(curr!=0 && curr-> data < value){
+        prev=curr;
+        curr=curr->next;
+    }
+
+    if(curr!=0 && curr->data == value){
+        if(prev == 0){
+            *head = curr->next;
+            free(curr);
+        }else{
+            prev->next = curr->next;
+            free(curr);
+        }
+        return 1;
+    }else{
+        return 0;
+    }
+}
+
+void Populate_list(int seed, struct node** head, int n){
+    srand(seed);
+    *head = malloc(sizeof(struct node));
+    (*head)->data = rand() % (MAX_NUMBER + 1);
+    int result = 0;
+
+    for(int i=0;i<n-1;i++){
+        result = Insert(rand() % (MAX_NUMBER + 1),head);
+        if(!result){
+            i=i-1;
+        }
+    }
+}
+
+void* Thread_operation(void* rank){
+
+    int thread_max_member_number = max_member_number/thread_count;
+    int thread_max_insert_number = max_insert_number/thread_count;
+    int thread_max_delete_number = max_delete_number/thread_count;
+    int thread_member_number=0;
+    int thread_insert_number=0;
+    int thread_delete_number=0;
+    srand(seed);
+    int operation;
+    int random_number;
+
+    while(thread_member_number<thread_max_member_number || thread_insert_number<thread_max_insert_number || thread_delete_number<thread_max_delete_number){
+        random_number = rand() % (MAX_NUMBER+1);
+        operation = random_number % 3;
+
+        if(operation==0 && thread_member_number < thread_max_member_number){
+                thread_member_number++;
+
+                Member(random_number, *head_node);
+        }
+        else if(operation==1 && thread_insert_number < thread_max_insert_number){
+                thread_insert_number++;
+                Insert(random_number, head_node);
+
+        }
+        else if(operation==2 && thread_delete_number < thread_max_delete_number){
+                thread_delete_number++;
+
+                Delete(random_number, head_node);
+        }
+
+    }
+    return 0;
+}
+
+
+int main()
+{
+    head_node = malloc(sizeof(struct node*));
+
+
+    pthread_mutex_init(&list_mutex, 0);
+
+    int iterations=0;
+    initial_length=1000;
+    max_m_operations=10000;
+    member_fraction=0.99;
+    insert_fraction=0.005;
+    delete_fraction=0.005;
+    thread_count=4;
+
+    printf(""Enter number of samples: "");
+    scanf(""%d"",&iterations);
+    printf(""Enter n: "");
+    scanf(""%d"",&initial_length);
+    printf(""Enter m: "");
+    scanf(""%d"",&max_m_operations);
+    printf(""Enter member_fraction: "");
+    scanf(""%lf"",&member_fraction);
+    printf(""Enter insert_fraction: "");
+    scanf(""%lf"",&insert_fraction);
+    printf(""Enter delete_fraction: "");
+    scanf(""%lf"",&delete_fraction);
+    printf(""Enter thread count: "");
+    scanf(""%d"",&thread_count);
+
+    double timespent[iterations];
+    for(seed=10; seed<11+iterations; seed++){
+        Populate_list(seed, head_node, initial_length);
+
+        max_member_number = (int)max_m_operations*member_fraction;
+        max_insert_number = (int)max_m_operations*insert_fraction;
+        max_delete_number = (int)max_m_operations*delete_fraction;
+
+        clock_t begin = clock();
+
+        pthread_t threads[thread_count];
+        long thread;
+        for(thread=0;thread<thread_count;thread++){
+            pthread_create(&threads[thread], 0, Thread_operation, (void*) thread);
+        }
+
+        for(thread=0; thread<thread_count;thread++){
+            pthread_join(threads[thread],0);
+        }
+
+        clock_t end = clock();
+        double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+        timespent[seed-10]=time_spent;
+
+        printf(""Percentage Complete: %.0f %%"",((seed-10)*100)/(float)iterations);
+        printf(""\\r"");
+    }
+
+
+    double sum=0, sum_var=0, average=0, std_deviation=0, variance=0;
+    for (int i = 0; i < iterations; i++)
+    {
+        sum += timespent[i];
+    }
+    average = sum / (float)iterations;
+
+    for (int i = 0; i < iterations; i++)
+    {
+        sum_var = sum_var + pow((timespent[i] - average), 2);
+    }
+    variance = sum_var / (float)(iterations-1);
+    std_deviation = sqrt(variance);
+
+    printf(""Average: %f, std_deviation: %f\\n"",average,std_deviation);
+
+    return 0;
+}
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <errno.h>
+
+struct dns_discovery_args {
+  FILE *report;
+  char *domain;
+  int nthreads;
+};
+struct dns_discovery_args dd_args;
+pthread_mutex_t mutexsum;
+
+void error(const char *msg) {
+  perror(msg);
+  exit(1);
+}
+
+FILE *ck_fopen(const char *path, const char *mode) {
+  FILE *file = fopen(path, mode);
+  if (file == 0) error(""fopen"");
+  return file;
+}
+
+void *ck_malloc(size_t size) {
+  void *ptr = malloc(size);
+  if (ptr == 0) error(""malloc"");
+  return ptr;
+}
+
+void chomp(char *str) {
+  while (*str) {
+    if (*str == '\\n' || *str == '\\r') {
+      *str = 0;
+      return;
+    }
+    str++;
+  }
+}
+
+void banner() {
+  printf(""   ___  _  ______    ___  _                              \\n""
+         ""  / _ \\\\/ |/ / __/___/ _ \\\\(_)__ _______ _  _____ ______ __\\n""
+         "" / // /    /\\\\ \\\\/___/ // / (_-</ __/ _ \\\\ |/ / -_) __/ // /\\n""
+         ""/____/_/|_/___/   /____/_/___/\\\\__/\\\\___/___/\\\\__/_/  \\\\_, / \\n""
+         ""                                                  /___/  \\n""
+         ""\\tby m0nad\\n\\n"");
+  if (dd_args.report) {
+    fprintf(dd_args.report, ""   ___  _  ______    ___  _                              \\n""
+                            ""  / _ \\\\/ |/ / __/___/ _ \\\\(_)__ _______ _  _____ ______ __\\n""
+                            "" / // /    /\\\\ \\\\/___/ // / (_-</ __/ _ \\\\ |/ / -_) __/ // /\\n""
+                            ""/____/_/|_/___/   /____/_/___/\\\\__/\\\\___/___/\\\\__/_/  \\\\_, / \\n""
+                            ""                                                  /___/  \\n""
+                            ""\\tby m0nad\\n\\n"");
+  }
+}
+
+int usage() {
+  printf(""usage: ./dns-discovery <domain> [options]\\n""
+         ""options:\\n""
+         ""\\t-w <wordlist file> (default : %s)\\n""
+         ""\\t-t <threads> (default : 1)\\n""
+         ""\\t-r <report file>\\n"", ""wordlist.wl"");
+  if (dd_args.report) {
+    fprintf(dd_args.report, ""usage: ./dns-discovery <domain> [options]\\n""
+                            ""options:\\n""
+                            ""\\t-w <wordlist file> (default : %s)\\n""
+                            ""\\t-t <threads> (default : 1)\\n""
+                            ""\\t-r <report file>\\n"", ""wordlist.wl"");
+  }
+  exit(0);
+}
+
+FILE *parse_args(int argc, char **argv) {
+  FILE *wordlist = 0;
+  char c, *ptr_wl = ""wordlist.wl"";
+  if (argc < 2) usage();
+  dd_args.domain = argv[1];
+  dd_args.nthreads = 1;
+  printf(""DOMAIN: %s\\n"", dd_args.domain);
+  if (dd_args.report) fprintf(dd_args.report, ""DOMAIN: %s\\n"", dd_args.domain);
+  argc--;
+  argv++;
+  opterr = 0;
+  while ((c = getopt(argc, argv, ""r:w:t:"")) != -1) {
+    switch (c) {
+      case 'w':
+        ptr_wl = optarg;
+        break;
+      case 't':
+        printf(""THREADS: %s\\n"", optarg);
+        if (dd_args.report) fprintf(dd_args.report, ""THREADS: %s\\n"", optarg);
+        dd_args.nthreads = atoi(optarg);
+        break;
+      case 'r':
+        printf(""REPORT: %s\\n"", optarg);
+        if (dd_args.report) fprintf(dd_args.report, ""REPORT: %s\\n"", optarg);
+        dd_args.report = ck_fopen(optarg, ""a"");
+        break;
+      case '?':
+        if (optopt == 'r' || optopt == 'w' || optopt == 't') {
+          fprintf(stderr, ""Option -%c requires an argument.\\n"", optopt);
+          exit(1);
+        }
+      default:
+        usage();
+    }
+  }
+  printf(""WORDLIST: %s\\n"", ptr_wl);
+  if (dd_args.report) fprintf(dd_args.report, ""WORDLIST: %s\\n"", ptr_wl);
+  wordlist = ck_fopen(ptr_wl, ""r"");
+
+  printf(""\\n"");
+  if (dd_args.report) fprintf(dd_args.report, ""\\n"");
+  return wordlist;
+}
+
+void resolve_lookup(const char *hostname) {
+  int ipv = 0;
+  char addr_str[256];
+  void *addr_ptr = 0;
+  struct addrinfo *res, *ori_res, hints;
+
+  memset(&hints, 0, sizeof hints);
+  hints.ai_family = PF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags |= AI_CANONNAME;
+
+  if (getaddrinfo(hostname, 0, &hints, &res) == 0) {
+    pthread_mutex_lock(&mutexsum);
+    printf(""%s\\n"", hostname);
+    if (dd_args.report) fprintf(dd_args.report, ""%s\\n"", hostname);
+    for (ori_res = res; res; res = res->ai_next) {
+      switch (res->ai_family) {
+        case AF_INET:
+          ipv = 4;
+          addr_ptr = &((struct sockaddr_in *) res->ai_addr)->sin_addr;
+          break;
+        case AF_INET6:
+          ipv = 6;
+          addr_ptr = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
+          break;
+      }
+      inet_ntop(res->ai_family, addr_ptr, addr_str, 256);
+      printf(""IPv%d address: %s\\n"", ipv, addr_str);
+      if (dd_args.report) fprintf(dd_args.report, ""IPv%d address: %s\\n"", ipv, addr_str);
+    }
+    printf(""\\n"");
+    if (dd_args.report) fprintf(dd_args.report, ""\\n"");
+    pthread_mutex_unlock(&mutexsum);
+    freeaddrinfo(ori_res);
+  }
+}
+
+void dns_discovery(FILE *file, const char *domain) {
+  char line[256];
+  char hostname[512];
+
+  while (fgets(line, sizeof line, file) != 0) {
+    chomp(line);
+    snprintf(hostname, sizeof hostname, ""%s.%s"", line, domain);
+    resolve_lookup(hostname);
+  }
+}
+
+void *dns_discovery_thread(void *args) {
+  FILE *wordlist = (FILE *) args;
+  FILE *local_wordlist = tmpfile();
+  char line[256];
+
+  pthread_mutex_lock(&mutexsum);
+  rewind(wordlist);
+  while (fgets(line, sizeof(line), wordlist)) {
+    fputs(line, local_wordlist);
+  }
+  pthread_mutex_unlock(&mutexsum);
+  rewind(local_wordlist);
+
+  dns_discovery(local_wordlist, dd_args.domain);
+
+  fclose(local_wordlist);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int i;
+  pthread_t *threads;
+  FILE *wordlist;
+
+  banner();
+  wordlist = parse_args(argc, argv);
+  threads = (pthread_t *) ck_malloc(dd_args.nthreads * sizeof(pthread_t));
+
+  pthread_mutex_init(&mutexsum, NULL);
+
+  for (i = 0; i < dd_args.nthreads; i++) {
+    if (pthread_create(&threads[i], 0, dns_discovery_thread, (void *) wordlist) != 0)
+      error(""pthread_create"");
+  }
+  for (i = 0; i < dd_args.nthreads; i++) {
+    pthread_join(threads[i], 0);
+  }
+
+  if (dd_args.report) fclose(dd_args.report);
+  free(threads);
+  fclose(wordlist);
+  return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+
+static int fd;
+static int disconnect;
+
+static char *ip;
+static char *port;
+static uint32_t cuid;
+
+static pthread_t hthid;
+static pthread_t rthid;
+
+static pthread_mutex_t fdlock;
+
+typedef struct _threc {
+ pthread_t thid;
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+ uint8_t *buff;
+ uint32_t buffsize;
+ uint8_t sent;
+ uint8_t status;
+ uint8_t release;
+ uint32_t size;
+ uint32_t cmd;
+ uint32_t packetid;
+ struct _threc *next;
+} threc;
+
+static threc *threc_head = 0;
+
+void fs_buffer_init(threc *rec,uint32_t size) {
+ if (size > 10000) {
+  rec->buff = realloc(rec->buff,size);
+  rec->buffsize = size;
+ } else if (rec->buffsize > 10000) {
+  rec->buff = realloc(rec->buff,10000);
+  rec->buffsize = 10000;
+ } else {
+  fprintf(stderr, ""null\\n"");
+ }
+}
+
+threc* fs_get_threc_by_id(uint32_t packetid) {
+ threc *rec;
+ for (rec = threc_head ; rec ; rec=rec->next) {
+  if (rec->packetid==packetid) {
+   return rec;
+  }
+ }
+ return 0;
+}
+
+void get_chunkid(uint8_t *data)
+{
+ uint64_t chunkid = 0;
+ int8_t status = 0;
+ uint8_t *ptr, hdr[16];
+
+if (DEBUG) {
+ fprintf(stderr, ""----get create chunk info ---\\n"");
+}
+ GET64BIT(chunkid, data);
+
+ status = create_file(chunkid);
+
+ if (status != 0) {
+  fprintf(stderr, ""create chunk file failed\\n"");
+ }
+
+
+ if (disconnect == 0 && fd >= 0) {
+ printf(""--------------\\n"");
+  ptr = hdr;
+  PUT32BIT(DATTOSER_CREAT_CHUNK, ptr);
+  PUT32BIT(8, ptr);
+  PUT32BIT(0, ptr);
+  PUT32BIT(status, ptr);
+
+  if (tcptowrite(fd, hdr, 16, 1000) != 16) {
+   disconnect = 1;
+  }
+ }
+
+}
+
+void analyze_ser_packet(uint32_t type, uint32_t size)
+{
+ uint8_t *data = 0;
+
+ data = malloc(size);
+ if (tcptoread(fd, data, size, 1000) != (int32_t)(size)) {
+  fprintf(stderr,""ser: tcp recv error(3)\\n"");
+  disconnect=1;
+  free(data);
+  return;
+ }
+ switch (type) {
+  case ANTOAN_NOP:
+   break;
+  case SERTODAT_DISK_INFO:
+   break;
+  case SERTODAT_CREAT_CHUNK:
+   get_chunkid(data);
+   break;
+  default:
+   break;
+
+ }
+ free(data);
+}
+
+int8_t analyze_ser_cmd(uint32_t type)
+{
+ switch (type) {
+  case ANTOAN_NOP:
+  case SERTODAT_DISK_INFO:
+  case SERTODAT_CREAT_CHUNK:
+   return 0;
+  default:
+   break;
+ }
+ return 1;
+}
+
+
+void connect_ser()
+{
+
+ fd = tcpsocket();
+
+ if (tcpconnect(fd, ip, port) < 0) {
+  fprintf(stderr, ""can't connect to ser(ip:%s,port:%s)\\n"", ip, port);
+  tcpclose(fd);
+  fd = -1;
+  return;
+ } else {
+  fprintf(stderr, ""connect to ser(ip:%s,port:%s)\\n"", ip, port);
+  disconnect = 0;
+ }
+
+}
+
+void *heartbeat_thread(void *arg)
+{
+ uint8_t *ptr, hdr[28];
+ uint64_t totalspace;
+ uint64_t freespace;
+
+ totalspace = 201;
+ freespace = 102;
+ while (1) {
+
+  if (disconnect == 0 && fd >= 0) {
+   ptr = hdr;
+   PUT32BIT(DATTOSER_DISK_INFO, ptr);
+   PUT32BIT(20, ptr);
+   PUT32BIT(0, ptr);
+   PUT64BIT(totalspace, ptr);
+   PUT64BIT(freespace, ptr);
+
+  printf(""heart beat\\n"");
+   if (tcptowrite(fd, hdr, 28, 1000) != 28) {
+    disconnect = 1;
+   }
+  }
+
+  sleep(5);
+ }
+}
+
+void *receive_thread(void *arg)
+{
+ uint8_t *ptr = 0;
+ uint8_t hdr[12] = {0};
+ uint32_t cmd = 0;
+ uint32_t size = 0;
+ uint32_t packetid = 0;
+ int r = 0;
+ threc *rec = 0;
+
+ for (;;) {
+  pthread_mutex_lock(&fdlock);
+  if (fd == -1 && disconnect) {
+   connect_ser();
+  }
+
+  if (disconnect) {
+   tcpclose(fd);
+   fd = -1;
+
+   for (rec = threc_head; rec; rec=rec->next) {
+
+   }
+  }
+
+  if (fd == -1) {
+   fprintf(stderr, ""reconnect ser(ip:%s,port:%s)\\n"", ip, port);
+   sleep(2);
+
+   continue;
+  }
+
+
+  r = read(fd,hdr,12);
+
+  if (r==0) {
+   fprintf(stderr, ""ser: connection lost (1)\\n"");
+   disconnect=1;
+   continue;
+  }
+  if (r!=12) {
+   fprintf(stderr,""ser: tcp recv error(1), %d\\n"", r);
+   disconnect=1;
+   continue;
+  }
+
+  ptr = hdr;
+  GET32BIT(cmd,ptr);
+  GET32BIT(size,ptr);
+  GET32BIT(packetid,ptr);
+
+ fprintf(stderr, ""read, cmd:%u\\n"", cmd);
+ fprintf(stderr, ""read, size:%u\\n"", size);
+ fprintf(stderr, ""read, packetid:%u\\n"", packetid);
+
+  if (cmd==ANTOAN_NOP && size==4) {
+
+   continue;
+  }
+  if (size < 4) {
+   fprintf(stderr,""ser: packet too small\\n"");
+   disconnect=1;
+   continue;
+  }
+  size -= 4;
+
+
+  if (analyze_ser_cmd(cmd) == 0) {
+   analyze_ser_packet(cmd, size);
+   continue;
+  }
+
+  rec = fs_get_threc_by_id(packetid);
+  if (rec == 0) {
+   fprintf(stderr, ""ser: get unexpected queryid\\n"");
+   disconnect=1;
+   continue;
+  }
+  fs_buffer_init(rec,rec->size+size);
+  if (rec->buff == 0) {
+   disconnect=1;
+   continue;
+  }
+
+  if (size>0) {
+   r = tcptoread(fd,rec->buff+rec->size,size,1000);
+
+int i;
+fprintf(stderr, ""read buf:%s, size:%d\\n"", rec->buff, size);
+for(i = 0; i< size; i++) {
+ fprintf(stderr, ""%u-"", rec->buff[rec->size+i]);
+}
+fprintf(stderr, ""\\n"");
+
+
+   if (r == 0) {
+    fprintf(stderr,""ser: connection lost (2)\\n"");
+    disconnect=1;
+    continue;
+   }
+   if (r != (int32_t)(size)) {
+    fprintf(stderr,""ser: tcp recv error(2)\\n"");
+    disconnect=1;
+    continue;
+   }
+  }
+  rec->sent=0;
+  rec->status=0;
+  rec->size = size;
+  rec->cmd = cmd;
+
+  rec->release = 1;
+
+    
+
+  pthread_cond_signal(&(rec->cond));
+ }
+}
+
+void ser_init(char *_ip, char *_port)
+{
+
+ ip = strdup(_ip);
+ port = strdup(_port);
+ cuid = 0;
+ fd = -1;
+ disconnect = 1;
+
+ pthread_mutex_init(&fdlock,0);
+ pthread_create(&rthid, 0, receive_thread, 0);
+
+
+}
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <string.h>
+#include <assert.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <linux/input.h>
+#include <mpd/client.h>
+#include <stdarg.h>
+
+#define MAX_CHANNEL 6
+
+enum log_level {
+    DEBUG = 0,
+    INFO = 1,
+    ERROR = 2
+};
+
+pthread_t tid[1];
+pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
+
+int g_isRunning = 1;
+int g_logLevel = DEBUG;
+
+struct mpd_connection *conn;
+
+void INT_handler(int sig) {
+    g_isRunning = 0;
+}
+
+void log_message(int level, const char *format, ...) {
+    if (level >= g_logLevel) {
+        va_list arglist;
+        va_start(arglist, format);
+        vfprintf(stderr, format, arglist);
+        va_end(arglist);
+        fprintf(stderr, ""\\n"");
+    }
+}
+
+static int handle_error(struct mpd_connection *c) {
+    int err = mpd_connection_get_error(c);
+
+    assert(err != MPD_ERROR_SUCCESS);
+
+    log_message(DEBUG, ""%d --> %s"", err, mpd_connection_get_error_message(c));
+    mpd_connection_free(c);
+    return 1;
+}
+
+bool run_play_pos(struct mpd_connection *c, int pos) {
+    if (!mpd_run_play_pos(c, pos)) {
+        if (mpd_connection_get_error(c) != MPD_ERROR_SERVER)
+            return handle_error(c);
+    }
+    return true;
+}
+
+void finish_command(struct mpd_connection *conn) {
+    if (!mpd_response_finish(conn)) {
+        handle_error(conn);
+    }
+}
+
+struct mpd_status* get_status(struct mpd_connection *conn) {
+    struct mpd_status *ret = mpd_run_status(conn);
+    if (ret == NULL) {
+        handle_error(conn);
+    }
+    return ret;
+}
+
+void* monitor(void *arg) {
+    pthread_t id = pthread_self();
+    unsigned long cnt = 0;
+    while (g_isRunning) {
+        log_message(INFO, ""%lu: thread keepalive %10ld"", (unsigned long)id, cnt);
+        pthread_mutex_lock(&mutex1);
+        if (!mpd_run_change_volume(conn, 0)) {
+            if (!mpd_connection_clear_error(conn)) {
+                handle_error(conn);
+            }
+        }
+        cnt++;
+        pthread_mutex_unlock(&mutex1);
+        usleep(5000000);
+    }
+    log_message(INFO, ""%lu: leaving thread"", (unsigned long)id);
+    pthread_exit(NULL);
+}
+
+int main() {
+    char devname[] = ""/dev/input/event0"";
+    int device;
+    struct input_event ev;
+    struct mpd_status* mpd_state_ptr;
+    int rc;
+    pthread_attr_t attr;
+    void *status;
+
+
+    signal(SIGINT, INT_handler);
+
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+    conn = mpd_connection_new(NULL, 0, 30000);
+    if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
+        return handle_error(conn);
+    }
+
+    rc = pthread_create(&tid[0], &attr, &monitor, NULL);
+    pthread_attr_destroy(&attr);
+
+    device = open(devname, O_RDONLY);
+    if (device < 0) {
+        perror(""Error opening device"");
+        mpd_connection_free(conn);
+        exit(EXIT_FAILURE);
+    }
+
+    while (g_isRunning) {
+        if (read(device, &ev, sizeof(ev)) <= 0) {
+            perror(""Error reading device"");
+            continue;
+        }
+
+        if (ev.type != EV_KEY) continue;
+
+        pthread_mutex_lock(&mutex1);
+        switch (ev.code) {
+            case KEY_POWER:
+                log_message(INFO, "">>> POWER"");
+                break;
+            case KEY_MUTE:
+                if (ev.value == 1) {
+                    if (!mpd_run_change_volume(conn, -1)) {
+                        if (!mpd_connection_clear_error(conn))
+                            handle_error(conn);
+                    }
+                    log_message(INFO, "">>> MUTE"");
+                }
+                break;
+            case KEY_STOP:
+                if (ev.value == 1) {
+                    mpd_state_ptr = get_status(conn);
+                    if (mpd_status_get_state(mpd_state_ptr) == MPD_STATE_PLAY ||
+                        mpd_status_get_state(mpd_state_ptr) == MPD_STATE_PAUSE) {
+                        if (!mpd_run_stop(conn))
+                            handle_error(conn);
+                        log_message(INFO, "">>> STOP"");
+                    }
+                    mpd_status_free(mpd_state_ptr);
+                }
+                break;
+            case KEY_PLAYPAUSE:
+                if (ev.value == 1) {
+                    mpd_state_ptr = get_status(conn);
+                    switch (mpd_status_get_state(mpd_state_ptr)) {
+                        case MPD_STATE_PLAY:
+                            mpd_send_pause(conn, true);
+                            finish_command(conn);
+                            break;
+                        case MPD_STATE_PAUSE:
+                        case MPD_STATE_STOP:
+                            if (!mpd_run_play(conn))
+                                handle_error(conn);
+                            break;
+                        default:
+                            break;
+                    }
+                    mpd_status_free(mpd_state_ptr);
+                    log_message(INFO, "">>> PLAYPAUSE"");
+                }
+                break;
+ 
+            default:
+                continue;
+        }
+
+        log_message(DEBUG, ""\\tKey: %i/0x%x Type: %i State: %i"", ev.code, ev.code, ev.type, ev.value);
+        pthread_mutex_unlock(&mutex1);
+    }
+
+    close(device);
+    pthread_mutex_destroy(&mutex1);
+
+    rc = pthread_join(tid[0], &status);
+    log_message(DEBUG, ""%lu: thread join (rc=%i)"", (unsigned long)tid[0], rc);
+
+    mpd_connection_free(conn);
+    return 0;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <math.h>
+#include <unistd.h>
+#include <errno.h>
+
+// Constants
+#define CG_MAX 4
+#define ND 4
+#define X_MAX 4
+#define Z_MAX 4
+#define ROW 2
+#define COL 2
+#define d 1
+
+// Global variables
+pthread_mutex_t mut1, mut2;
+pthread_cond_t cond1, cond2;
+int g_status;
+
+// Forward declarations
+void master_wait();
+void master_signal(struct Param **params);
+void slave_wait(struct Param *param);
+void slave_signal();
+void compute_ldm(struct Param *param);
+
+// Param structure definition
+struct Param {
+    int nx, nz, nb, ldnx, ldnz, freeSurface, id, nd, icg, status, exit;
+    int gnxbeg, gnzbeg;
+    const float *prev_wave, *curr_wave, *vel;
+    float *next_wave, *u2, *src_wave, *vsrc_wave, *image, scale;
+    int crnx, crnz, task;
+    struct Param **params;
+};
+
+// Function definitions
+
+void master_wait() {
+
+    while (g_status != 0) {
+        pthread_cond_wait(&cond1, &mut1);
+    }
+
+    g_status = CG_MAX;
+}
+
+void master_signal(struct Param **params) {
+    int i;
+
+    for (i = 0; i < CG_MAX; i++) {
+        params[i * ND]->status = 0;
+    }
+    pthread_cond_broadcast(&cond2);
+
+}
+
+void slave_wait(struct Param *param) {
+
+    while (param->status) {
+        pthread_cond_wait(&cond2, &mut2);
+    }
+
+}
+
+void slave_signal() {
+
+    g_status--;
+    pthread_cond_signal(&cond1);
+
+}
+
+void compute_ldm(struct Param *param) {
+    int nx = param->nx;
+    int nz = param->nz;
+    int nb = param->nb;
+    int cnx = nx - 2 * d;
+    int cnz = nz - 2 * d;
+    int snx = ceil(cnx * 1.0 / ROW);
+    int snz = ceil(cnz * 1.0 / COL);
+    int cid = 0;
+    int rid = 0;
+    int snxbeg = snx * cid - d + d;
+    int snzbeg = snz * rid - d + d;
+    int snxend = snx * (cid + 1) + d + d;
+    int snzend = snz * (rid + 1) + d + d;
+    snxend = snxend < nx ? snxend : nx;
+    snzend = snzend < nz ? snzend : nz;
+    snx = snxend - snxbeg;
+    snz = snzend - snzbeg;
+    int vel_size = (snx - 2 * d) * (snz - 2 * d) * sizeof(float);
+    int curr_size = snx * snz * sizeof(float);
+    int total = vel_size * 2 + curr_size * 2 + nb * sizeof(float) + 6 * sizeof(float);
+    printf(""LDM consume: vel_size = %dB, curr_size = %dB, total = %dB\\n"", vel_size, curr_size, total);
+}
+
+int fd4t10s_4cg(void *ptr) {
+    struct Param *param = (struct Param *)ptr;
+    struct Param **params = param->params;
+
+    compute_ldm(param);
+    while (1) {
+        slave_wait(param);
+        if (param->exit) {
+            break;
+        }
+        param->status = 1;
+        int i;
+        for (i = 0; i < ND; i++) {
+            param = params[param->id + i];
+            if (param->task == 0) {
+                // Simulating work done by threads (replace with actual implementation)
+            } else if (param->task == 1) {
+                // Simulating work done by threads (replace with actual implementation)
+            }
+            param = params[param->id];
+        }
+        slave_signal();
+    }
+    return 0;
+}
+
+pthread_t pt[CG_MAX];
+struct Param *params[X_MAX * Z_MAX];
+
+void fd4t10s_nobndry_zjh_2d_vtrans_cg(const float *prev_wave, const float *curr_wave, float *next_wave, const float *vel, float *u2, int nx, int nz, int nb, int nt, int freeSurface) {
+    static int init = 1;
+    if (init) {
+        if (pthread_mutex_init(&mut1, NULL) != 0 || pthread_mutex_init(&mut2, NULL) != 0) {
+            printf(""Mutex init error\\n"");
+            exit(EXIT_FAILURE);
+        }
+
+        if (pthread_cond_init(&cond1, NULL) != 0 || pthread_cond_init(&cond2, NULL) != 0) {
+            printf(""Cond init error\\n"");
+            exit(EXIT_FAILURE);
+        }
+
+        for (int ix = 0; ix < X_MAX; ix++) {
+            int cnx = nx - 2 * d;
+            int snx = ceil(cnx * 1.0 / X_MAX);
+            int snxbeg = snx * ix - d + d;
+            int snxend = snx * (ix + 1) + d + d;
+            snxend = snxend < nx ? snxend : nx;
+            snx = snxend - snxbeg;
+            for (int iz = 0; iz < Z_MAX; iz++) {
+                int cnz = nz - 2 * d;
+                int snz = ceil(cnz * 1.0 / Z_MAX);
+                int snzbeg = snz * iz - d + d;
+                int snzend = snz * (iz + 1) + d + d;
+                snzend = snzend < nz ? snzend : nz;
+                snz = snzend - snzbeg;
+                int id = ix * Z_MAX + iz;
+                params[id] = (struct Param *)malloc(sizeof(struct Param));
+                if (params[id] == NULL) {
+                    perror(""malloc failed"");
+                    exit(EXIT_FAILURE);
+                }
+                params[id]->nx = snx;
+                params[id]->nz = snz;
+                params[id]->ldnx = nx;
+                params[id]->ldnz = nz;
+                params[id]->nb = nb;
+                params[id]->freeSurface = freeSurface;
+                params[id]->id = id;
+                params[id]->nd = ND;
+                params[id]->icg = id / ND;
+                params[id]->status = 1;
+                params[id]->exit = 0;
+                params[id]->gnxbeg = snxbeg;
+                params[id]->gnzbeg = snzbeg;
+                params[id]->params = params;
+            }
+        }
+        g_status = CG_MAX;
+    }
+
+    if (init) {
+        for (int icg = 0; icg < CG_MAX; icg++) {
+            int id_beg = icg * ND;
+            if (pthread_create(&pt[icg], NULL, fd4t10s_4cg, (void *)params[id_beg]) != 0) {
+                perror(""pthread_create failed"");
+                exit(EXIT_FAILURE);
+            }
+        }
+        init = 0;
+    }
+
+    master_signal(params);
+    master_wait();
+}
+
+// Cleanup function
+void fd4t10s_4cg_exit() {
+    for (int icg = 0; icg < CG_MAX; icg++) {
+        params[icg * ND]->exit = 1;
+    }
+    master_signal(params);
+
+    for (int icg = 0; icg < CG_MAX; icg++) {
+        pthread_join(pt[icg], NULL);
+    }
+
+    for (int ix = 0; ix < X_MAX; ix++) {
+        for (int iz = 0; iz < Z_MAX; iz++) {
+            free(params[ix * Z_MAX + iz]);
+        }
+    }
+
+    pthread_mutex_destroy(&mut1);
+    pthread_mutex_destroy(&mut2);
+    pthread_cond_destroy(&cond1);
+    pthread_cond_destroy(&cond2);
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <errno.h>
+
+struct udp_splice_handle {
+    pthread_mutex_t lock;
+    int sock;
+    uint16_t id;
+};
+
+static int udp_splice_get_family_id(int sock) {
+    struct {
+        struct nlmsghdr nl;
+        char buf[4096];
+    } buf;
+    struct genlmsghdr *genl;
+    struct rtattr *rta;
+    struct sockaddr_nl addr = {
+        .nl_family = AF_NETLINK,
+    };
+    int len;
+
+    memset(&buf.nl, 0, sizeof(buf.nl));
+    buf.nl.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
+    buf.nl.nlmsg_flags = NLM_F_REQUEST;
+    buf.nl.nlmsg_type = GENL_ID_CTRL;
+
+    genl = (struct genlmsghdr *)buf.buf;
+    memset(genl, 0, sizeof(*genl));
+    genl->cmd = CTRL_CMD_GETFAMILY;
+
+    rta = (struct rtattr *)(genl + 1);
+    rta->rta_type = CTRL_ATTR_FAMILY_NAME;
+    rta->rta_len = RTA_LENGTH(sizeof(UDP_SPLICE_GENL_NAME));
+    memcpy(RTA_DATA(rta), UDP_SPLICE_GENL_NAME, sizeof(UDP_SPLICE_GENL_NAME));
+    buf.nl.nlmsg_len += rta->rta_len;
+
+    if (sendto(sock, &buf, buf.nl.nlmsg_len, 0, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        perror(""sendto failed"");
+        return -1;
+    }
+
+    len = recv(sock, &buf, sizeof(buf), 0);
+    if (len < 0) {
+        perror(""recv failed"");
+        return -1;
+    }
+    if (len < sizeof(buf.nl) || buf.nl.nlmsg_len != len) {
+        errno = EBADMSG;
+        return -1;
+    }
+    if (buf.nl.nlmsg_type == NLMSG_ERROR) {
+        struct nlmsgerr *errmsg = (struct nlmsgerr *)buf.buf;
+        errno = -errmsg->error;
+        return -1;
+    }
+
+    len -= sizeof(buf.nl) + sizeof(*genl);
+    while (RTA_OK(rta, len)) {
+        if (rta->rta_type == CTRL_ATTR_FAMILY_ID) {
+            return *(uint16_t *)RTA_DATA(rta);
+        }
+        rta = RTA_NEXT(rta, len);
+    }
+
+    errno = EBADMSG;
+    return -1;
+}
+
+void *udp_splice_open(void) {
+    struct udp_splice_handle *h;
+    int retval;
+    struct sockaddr_nl addr;
+
+    h = malloc(sizeof(*h));
+    if (!h) {
+        perror(""malloc failed"");
+        return NULL;
+    }
+
+    retval = pthread_mutex_init(&h->lock, NULL);
+    if (retval) {
+        errno = retval;
+        free(h);
+        return NULL;
+    }
+
+    h->sock = socket(PF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, NETLINK_GENERIC);
+    if (h->sock < 0) {
+        perror(""socket creation failed"");
+        pthread_mutex_destroy(&h->lock);
+        free(h);
+        return NULL;
+    }
+
+    memset(&addr, 0, sizeof(addr));
+    addr.nl_family = AF_NETLINK;
+    if (bind(h->sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        perror(""bind failed"");
+        close(h->sock);
+        pthread_mutex_destroy(&h->lock);
+        free(h);
+        return NULL;
+    }
+
+    retval = udp_splice_get_family_id(h->sock);
+    if (retval < 0) {
+        close(h->sock);
+        pthread_mutex_destroy(&h->lock);
+        free(h);
+        return NULL;
+    }
+
+    h->id = retval;
+    return h;
+}
+
+int udp_splice_add(void *handle, int sock, int sock2, uint32_t timeout) {
+    struct {
+        struct nlmsghdr nl;
+        struct genlmsghdr genl;
+        char attrs[RTA_LENGTH(4) * 3];
+    } req;
+    struct {
+        struct nlmsghdr nl;
+        struct nlmsgerr err;
+    } res;
+    struct rtattr *rta;
+    struct sockaddr_nl addr = { .nl_family = AF_NETLINK };
+    int len;
+    struct udp_splice_handle *h = handle;
+
+    memset(&req, 0, sizeof(req.nl) + sizeof(req.genl));
+    req.nl.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
+    req.nl.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
+    req.nl.nlmsg_type = h->id;
+
+    req.genl.cmd = UDP_SPLICE_CMD_ADD;
+
+    rta = (struct rtattr *)req.attrs;
+    rta->rta_type = UDP_SPLICE_ATTR_SOCK;
+    rta->rta_len = RTA_LENGTH(4);
+    *(uint32_t *)RTA_DATA(rta) = sock;
+    req.nl.nlmsg_len += rta->rta_len;
+
+    rta = (struct rtattr *)(((char *)rta) + rta->rta_len);
+    rta->rta_type = UDP_SPLICE_ATTR_SOCK2;
+    rta->rta_len = RTA_LENGTH(4);
+    *(uint32_t *)RTA_DATA(rta) = sock2;
+    req.nl.nlmsg_len += rta->rta_len;
+
+    if (timeout) {
+        rta = (struct rtattr *)(((char *)rta) + rta->rta_len);
+        rta->rta_type = UDP_SPLICE_ATTR_TIMEOUT;
+        rta->rta_len = RTA_LENGTH(4);
+        *(uint32_t *)RTA_DATA(rta) = timeout;
+        req.nl.nlmsg_len += rta->rta_len;
+    }
+
+    pthread_mutex_lock(&h->lock);
+    if (sendto(h->sock, &req, req.nl.nlmsg_len, 0, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        pthread_mutex_unlock(&h->lock);
+        perror(""sendto failed"");
+        return -1;
+    }
+
+    len = recv(h->sock, &res, sizeof(res), 0);
+    pthread_mutex_unlock(&h->lock);
+
+    if (len < 0) {
+        perror(""recv failed"");
+        return -1;
+    }
+    if (len != sizeof(res) || res.nl.nlmsg_type != NLMSG_ERROR) {
+        errno = EBADMSG;
+        return -1;
+    }
+    if (res.err.error) {
+        errno = -res.err.error;
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+
+static char *root;
+static int workers;
+static int trials;
+static int record_absolute;
+static struct timeval asbolute_start;
+
+static pthread_mutex_t worker_sync_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t worker_sync_cond = PTHREAD_COND_INITIALIZER;
+static volatile int worker_sync_t = -1;
+static volatile int workers_alive = 0;
+
+int timeval_subtract(struct timeval *result, struct timeval *x,
+                     struct timeval *y) {
+    if(x->tv_usec < y->tv_usec) {
+        int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
+        y->tv_usec -= 1000000 * nsec;
+        y->tv_sec += nsec;
+    }
+    if(x->tv_usec - y->tv_usec > 1000000) {
+        int nsec = (x->tv_usec - y->tv_usec) / 1000000;
+        y->tv_usec += 1000000 * nsec;
+        y->tv_sec -= nsec;
+    }
+
+    result->tv_sec = x->tv_sec - y->tv_sec;
+    result->tv_usec = x->tv_usec - y->tv_usec;
+
+    return x->tv_sec < y->tv_sec;
+}
+
+static void pthread_usleep(unsigned int usecs) {
+    int result;
+    pthread_cond_t timercond = PTHREAD_COND_INITIALIZER;
+    pthread_mutex_t timerlock = PTHREAD_MUTEX_INITIALIZER;
+    struct timespec timerexpires;
+
+    clock_gettime(CLOCK_REALTIME, &timerexpires);
+    timerexpires.tv_nsec += usecs * 1000;
+    if(timerexpires.tv_nsec >= 1000000000) {
+        timerexpires.tv_sec += timerexpires.tv_nsec / 1000000000;
+        timerexpires.tv_nsec = timerexpires.tv_nsec % 1000000000;
+    }
+
+
+    result = ~ETIMEDOUT;
+    while(result != ETIMEDOUT)
+        result = pthread_cond_timedwait(&timercond, &timerlock, &timerexpires);
+
+}
+
+void *worker_run(void *data) {
+    int id = (int) data;
+
+    char clkpath[256];
+    sprintf(clkpath, ""%s/clock"", root);
+
+    int clkfd = open(clkpath, O_RDONLY);
+    if(clkfd < 0) {
+        perror(""open"");
+        exit(1);
+    }
+
+    char testpath[256];
+    sprintf(testpath, ""%s/%d"", root, id);
+
+    int fd = open(testpath, O_RDWR | O_CREAT, 0777);
+    if(fd < 0) {
+        perror(""open"");
+        exit(1);
+    }
+
+    char buf[1024];
+    memset(buf, 'x', sizeof(buf));
+    ((int *) buf)[0] = id;
+
+    uint64_t *deltas = malloc(sizeof(uint64_t) * trials * 2);
+
+
+    workers_alive++;
+
+
+
+    if(id == 0) {
+        while(workers_alive < workers)
+            pthread_usleep(100000);
+
+        struct stat statbuf;
+        if(fstat(clkfd, &statbuf) < 0) {
+            perror(""fstat"");
+            exit(1);
+        }
+    }
+
+    int t;
+    for(t = 0; ; t++) {
+        if(id == 0) {
+            if(t >= trials && workers_alive == 1)
+                break;
+        } else {
+            if(t >= trials)
+                break;
+
+
+            while(worker_sync_t < t)
+                pthread_cond_wait(&worker_sync_cond, &worker_sync_lock);
+
+        }
+
+        struct timeval before;
+        gettimeofday(&before, 0);
+
+        if(lseek(fd, 0, 0) < 0) {
+            perror(""lseek"");
+            exit(1);
+        }
+        if(write(fd, buf, sizeof(buf)) < 0) {
+            perror(""write"");
+            exit(1);
+        }
+
+        struct timeval after;
+        gettimeofday(&after, 0);
+
+        struct timeval diff;
+        if(record_absolute)
+            timeval_subtract(&diff, &after, &asbolute_start);
+        else
+            timeval_subtract(&diff, &after, &before);
+
+        deltas[t] = (diff.tv_sec * 1000000) + diff.tv_usec;
+
+        if(id == 0) {
+            pthread_mutex_lock(&worker_sync_lock);
+            worker_sync_t = t;
+            pthread_cond_broadcast(&worker_sync_cond);
+            pthread_mutex_unlock(&worker_sync_lock);
+
+            pthread_usleep(49000);
+        }
+    }
+
+    pthread_mutex_lock(&worker_sync_lock);
+    workers_alive--;
+    pthread_mutex_unlock(&worker_sync_lock);
+
+    return deltas;
+}
+
+int main(int argc, char *argv[]) {
+    if(argc < 4 || argc > 5) {
+        printf(""Usage: concurio [mount-point] [workers] [trials] [-a]\\n"");
+        exit(1);
+    }
+
+    root = argv[1];
+    workers = strtol(argv[2], 0, 10);
+    trials = strtol(argv[3], 0, 10);
+    if(argc == 5 && strcmp(argv[4], ""-a"") == 0)
+        record_absolute = 1;
+    else
+        record_absolute = 0;
+
+    gettimeofday(&asbolute_start, 0);
+
+    pthread_t *worker_threads = malloc(sizeof(pthread_t) * workers);
+
+    int w;
+    for(w = 0; w < workers; w++)
+        pthread_create(&worker_threads[w], 0, worker_run, (void *) w);
+
+    uint64_t **worker_deltas = malloc(sizeof(uint64_t *) * workers);
+    for(w = 0; w < workers; w++)
+        pthread_join(worker_threads[w], (void **) &worker_deltas[w]);
+
+    if(record_absolute)
+        printf(""absolute\\n"");
+    else
+        printf(""write-time\\n"");
+
+    int t;
+    for(w = 0; w < workers; w++) {
+        for(t = 0; t < trials; t++)
+            printf(""%d: %llu\\n"", w, worker_deltas[w][t]);
+        free(worker_deltas[w]);
+    }
+
+    exit(0);
+}
+",1
+"#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <pthread.h>
+#include <unistd.h>
+
+pthread_mutex_t* f;
+int* hungerOfPhylosophs;
+int N;
+
+void takeLeftFork(int);
+void takeRightFork(int);
+void putLeftFork(int);
+void putRightFork(int);
+void* meal(void*);
+
+int main()
+{
+    int Hunger, *Nums;
+    pthread_t* P;
+
+    while (1) {
+        printf(""Type number of philosophers and hunger of them:\\n"");
+        scanf(""%d%d"", &N, &Hunger);
+        if (N == 0) break;
+    
+    
+        f = (pthread_mutex_t*)malloc(N * sizeof(pthread_mutex_t));
+        hungerOfPhylosophs = (int*)malloc(N * sizeof(int));
+        P = (pthread_t*)malloc(N * sizeof(pthread_t));
+        Nums = (int*)malloc(N * sizeof(int));
+
+ 
+        for (int i = 0; i < N; i++) {
+            pthread_mutex_init(f + i, NULL);
+            hungerOfPhylosophs[i] = Hunger;
+            Nums[i] = i;
+        }
+
+  
+        for (int i = 0; i < N; i++) {
+            pthread_create(P + i, NULL, meal, Nums + i);
+        }
+
+
+        for (int i = 0; i < N; i++) {
+            pthread_join(P[i], NULL);
+        }
+
+
+        for (int i = 0; i < N; i++) {
+            pthread_mutex_destroy(f + i);
+        }
+        free(f);
+        free(hungerOfPhylosophs);
+        free(P);
+        free(Nums);
+
+        printf(""All philosophers finished\\n"");
+    }
+    return 0;
+}
+
+// Functions to pick up and put down the forks
+void takeLeftFork(int name) {
+    if (name == 0)
+        pthread_mutex_lock(f + N - 1); // Philosopher 0 picks the last fork as the left fork
+    else
+        pthread_mutex_lock(f + name - 1);
+}
+
+void takeRightFork(int name) {
+    pthread_mutex_lock(f + name);
+}
+
+void putLeftFork(int name) {
+    if (name == 0)
+        pthread_mutex_unlock(f + N - 1);
+    else
+        pthread_mutex_unlock(f + name - 1);
+}
+
+void putRightFork(int name) {
+    pthread_mutex_unlock(f + name);
+}
+
+
+void* meal(void* pName) {
+    int name = *(int*)pName;
+    while (hungerOfPhylosophs[name] > 0) {
+
+        if (name == 0) {
+            takeRightFork(name);
+            takeLeftFork(name);
+        } else {
+            takeLeftFork(name);
+            takeRightFork(name);
+        }
+
+
+        hungerOfPhylosophs[name]--;
+        printf(""Philosopher %d is eating for 3 seconds, hunger left: %d\\n"", name, hungerOfPhylosophs[name]);
+        sleep(3);
+
+
+        putLeftFork(name);
+        putRightFork(name);
+
+
+        printf(""Philosopher %d is thinking for 3 seconds\\n"", name);
+        sleep(3);
+    }
+    printf(""Philosopher %d has finished eating and is now only thinking\\n"", name);
+    return NULL;
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <string.h>
+
+int shared = 5;
+pthread_mutex_t lock;
+
+void sendreply(int replyfrompno, int replytopno, int ts) {
+    FILE *ptr;
+    char filename[10];
+    sprintf(filename, ""file%d.txt"", replytopno);
+    ptr = fopen(filename, ""a"");
+    if (ptr == NULL) {
+        perror(""Error opening file"");
+        exit(1);
+    }
+    fprintf(ptr, ""%d %d\\n"", replyfrompno, ts);
+    fclose(ptr);
+}
+
+void *process1(void *val) {
+    int replyfrom[4] = {0};
+    int clockvalue = 0;
+    int replyto[4] = {0};
+
+    FILE *ptr1, *ptr2, *ptr3;
+
+    printf(""--------------process1---------------\\n"");
+    ptr1 = fopen(""file1.txt"", ""r"");
+    if (ptr1 == NULL) {
+        perror(""Error opening file1.txt"");
+
+        exit(1);
+    }
+
+    int pno = 0, ts = 0, timefromotherprocess = 0;
+    while (fscanf(ptr1, ""%d %d"", &pno, &ts) != EOF) {
+        if (ts > 0 && (pno == 2 || pno == 3)) {
+            if (ts > timefromotherprocess)
+                timefromotherprocess = ts;
+        }
+    }
+
+    clockvalue = (clockvalue < timefromotherprocess) ? timefromotherprocess + 1 : clockvalue + 1;
+
+    printf(""file1 %d %d\\n"", pno, ts);
+    fclose(ptr1);
+    pthread_mutex_unlock(&lock);
+
+
+    printf(""--------------process1---------------\\n"");
+    ptr2 = fopen(""file2.txt"", ""a"");
+    ptr3 = fopen(""file3.txt"", ""a"");
+    if (ptr2 == NULL || ptr3 == NULL) {
+        perror(""Error opening file2.txt or file3.txt"");
+
+        exit(1);
+    }
+    fprintf(ptr2, ""%d %d\\n"", 1, clockvalue);
+    fprintf(ptr3, ""%d %d\\n"", 1, clockvalue);
+    fclose(ptr2);
+    fclose(ptr3);
+    pthread_mutex_unlock(&lock);
+
+    pthread_mutex_lock(&lock);
+    printf(""--------------process1---------------\\n"");
+    ptr1 = fopen(""file1.txt"", ""r"");
+    if (ptr1 == NULL) {
+        perror(""Error opening file1.txt"");
+        pthread_mutex_unlock(&lock);
+        exit(1);
+    }
+
+    while (fscanf(ptr1, ""%d %d"", &pno, &ts) != EOF) {
+        if (ts > 0 && (pno != 1)) {
+            sendreply(1, pno, -ts);
+            replyto[pno] = 1;
+        }
+
+        printf(""1file1 %d %d\\n"", pno, ts);
+    }
+    fclose(ptr1);
+    pthread_mutex_unlock(&lock);
+
+    while (1) {
+        pthread_mutex_lock(&lock);
+        printf(""--------------process1---------------\\n"");
+        ptr1 = fopen(""file1.txt"", ""r"");
+        if (ptr1 == NULL) {
+            perror(""Error opening file1.txt"");
+            pthread_mutex_unlock(&lock);
+            exit(1);
+        }
+
+        while (fscanf(ptr1, ""%d %d"", &pno, &ts) != EOF) {
+            if (ts < 0) {
+                replyfrom[pno] = 1;
+            }
+            printf(""1file1 %d %d\\n"", pno, ts);
+        }
+        if (replyfrom[2] == 1 && replyfrom[3] == 1) {
+            fclose(ptr1);
+            pthread_mutex_unlock(&lock);
+            break;
+        }
+        fclose(ptr1);
+        pthread_mutex_unlock(&lock);
+        sleep(2);
+    }
+
+    pthread_mutex_lock(&lock);
+    printf(""--------------process1---------------\\n"");
+    shared = shared + 10;
+    printf(""p1 did %d\\n"", shared);
+    pthread_mutex_unlock(&lock);
+
+    return NULL;
+}
+
+void *process2(void *val) {
+    // Implementation similar to process1
+    // Make sure to adjust file handling and synchronization similarly
+    return NULL;
+}
+
+void *process3(void *val) {
+    // Implementation similar to process1
+    // Make sure to adjust file handling and synchronization similarly
+    return NULL;
+}
+
+int main() {
+    pthread_t pt[3];
+    pthread_mutex_init(&lock, NULL);
+
+    pthread_create(&pt[0], NULL, process1, NULL);
+    pthread_create(&pt[1], NULL, process2, NULL);
+    pthread_create(&pt[2], NULL, process3, NULL);
+
+    pthread_join(pt[0], NULL);
+    pthread_join(pt[1], NULL);
+    pthread_join(pt[2], NULL);
+
+    pthread_mutex_destroy(&lock);
+    return 0;
+}
+
+",1
+"#include <stdio.h>
+#include <pthread.h>
+
+const int MAX_COUNT = 5;
+
+typedef enum {PING_INIT, PING_READY, PONG_READY} READY;
+READY g_ready = PING_INIT;
+pthread_mutex_t thr_cond_lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t thr_cond = PTHREAD_COND_INITIALIZER;
+
+void * thread_ping (void * arg)
+{
+ int i = 0;
+
+
+ pthread_mutex_lock(&thr_cond_lock);
+ g_ready = PING_READY;
+
+ pthread_cond_wait(&thr_cond, &thr_cond_lock);
+
+ while(1) { 
+  printf(""ping(%d) -> "", ++i);
+  pthread_cond_signal(&thr_cond);
+  if (i == MAX_COUNT) {
+   pthread_mutex_unlock(&thr_cond_lock);
+   break;
+  }
+  else
+   pthread_cond_wait(&thr_cond, &thr_cond_lock);
+ }
+
+ pthread_exit((void *)1); 
+}
+
+void * thread_pong (void * arg)
+{
+ int i = 0;
+
+
+ while(1) {
+  pthread_mutex_lock(&thr_cond_lock);
+  if (g_ready == PING_READY) {
+   pthread_cond_signal(&thr_cond); 
+
+   pthread_cond_wait(&thr_cond, &thr_cond_lock);
+   break;
+  } 
+  else
+   pthread_mutex_unlock(&thr_cond_lock);
+ }
+
+ while(1) {
+  printf(""pong(%d)\\n"", ++i);
+  pthread_cond_signal(&thr_cond);
+  if (i == MAX_COUNT) {
+   pthread_mutex_unlock(&thr_cond_lock);
+   break;
+  }
+  else
+   pthread_cond_wait(&thr_cond, &thr_cond_lock);
+ }
+  
+ pthread_exit((void *)2); 
+}
+
+int main()
+{
+ pthread_t pthread[2];
+ int result[2];
+
+ pthread_create(&pthread[1], NULL, thread_pong, NULL); 
+ pthread_create(&pthread[0], NULL, thread_ping, NULL); 
+
+ pthread_join(pthread[0], (void **)&result[0]);
+ pthread_join(pthread[1], (void **)&result[1]);
+
+
+ return 0;
+}
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <errno.h>
+#include ""uthash.h"" // Ensure you have this library or similar hash table library available
+
+#define TypeResponse 1
+#define TypeRead 2
+#define TypeWrite 3
+
+struct Message {
+    int Seq;
+    int Type;
+    off_t Offset;
+    size_t DataLength;
+    void *Data;
+    pthread_cond_t cond;
+    pthread_mutex_t mutex;
+};
+
+struct client_connection {
+    int fd;
+    int seq;
+    struct Message *msg_table;
+    pthread_mutex_t mutex;
+    pthread_t response_thread;
+};
+
+// Dummy functions for send_msg and receive_msg
+int send_msg(int fd, struct Message *msg) {
+    // Implement the actual sending logic here
+    return 0; // Placeholder for success
+}
+
+int receive_msg(int fd, struct Message *msg) {
+    // Implement the actual receiving logic here
+    return 0; // Placeholder for success
+}
+
+int send_request(struct client_connection *conn, struct Message *req) {
+    int rc = 0;
+
+
+    rc = send_msg(conn->fd, req);
+
+    return rc;
+}
+
+int receive_response(struct client_connection *conn, struct Message *resp) {
+    return receive_msg(conn->fd, resp);
+}
+
+void* response_process(void *arg) {
+    struct client_connection *conn = (struct client_connection *)arg;
+    struct Message *req, *resp;
+    int ret = 0;
+
+    resp = malloc(sizeof(struct Message));
+    if (resp == NULL) {
+        perror(""cannot allocate memory for resp"");
+        return NULL;
+    }
+
+    ret = receive_response(conn, resp);
+    while (ret == 0) {
+        if (resp->Type != TypeResponse) {
+            fprintf(stderr, ""Wrong type for response of seq %d\\n"", resp->Seq);
+            ret = receive_response(conn, resp);
+            continue;
+        }
+
+
+        HASH_FIND_INT(conn->msg_table, &resp->Seq, req);
+        if (req != NULL) {
+            HASH_DEL(conn->msg_table, req);
+        }
+
+
+        if (req != NULL) {
+ 
+            memcpy(req->Data, resp->Data, req->DataLength);
+            free(resp->Data);
+
+
+            pthread_cond_signal(&req->cond);
+        }
+
+        ret = receive_response(conn, resp);
+    }
+    free(resp);
+    if (ret != 0) {
+        fprintf(stderr, ""Receive response returned error\\n"");
+    }
+    return NULL;
+}
+
+void start_response_processing(struct client_connection *conn) {
+    int rc;
+
+    rc = pthread_create(&conn->response_thread, NULL, response_process, conn);
+    if (rc != 0) {
+        perror(""Fail to create response thread"");
+        exit(EXIT_FAILURE);
+    }
+}
+
+int new_seq(struct client_connection *conn) {
+    return __sync_fetch_and_add(&conn->seq, 1);
+}
+
+int process_request(struct client_connection *conn, void *buf, size_t count, off_t offset, uint32_t type) {
+    struct Message *req = malloc(sizeof(struct Message));
+    int rc = 0;
+
+    if (req == NULL) {
+        perror(""cannot allocate memory for req"");
+        return -ENOMEM;
+    }
+
+    if (type != TypeRead && type != TypeWrite) {
+        fprintf(stderr, ""BUG: Invalid type for process_request %d\\n"", type);
+        rc = -EFAULT;
+        free(req);
+        return rc;
+    }
+    req->Seq = new_seq(conn);
+    req->Type = type;
+    req->Offset = offset;
+    req->DataLength = count;
+    req->Data = buf;
+
+    if (req->Type == TypeRead) {
+        memset(req->Data, 0, count);
+    }
+
+    rc = pthread_cond_init(&req->cond, NULL);
+    if (rc != 0) {
+        perror(""Fail to init pthread_cond"");
+        free(req);
+        return -EFAULT;
+    }
+
+    rc = pthread_mutex_init(&req->mutex, NULL);
+    if (rc != 0) {
+        perror(""Fail to init pthread_mutex"");
+        pthread_cond_destroy(&req->cond);
+        free(req);
+        return -EFAULT;
+    }
+
+    pthread_mutex_lock(&conn->mutex);
+    HASH_ADD_INT(conn->msg_table, Seq, req);
+    pthread_mutex_unlock(&conn->mutex);
+
+    pthread_mutex_lock(&req->mutex);
+    rc = send_request(conn, req);
+    if (rc < 0) {
+        pthread_mutex_unlock(&req->mutex);
+        pthread_mutex_destroy(&req->mutex);
+        pthread_cond_destroy(&req->cond);
+        free(req);
+        return rc;
+    }
+
+    pthread_cond_wait(&req->cond, &req->mutex);
+    pthread_mutex_unlock(&req->mutex);
+
+    pthread_mutex_destroy(&req->mutex);
+    pthread_cond_destroy(&req->cond);
+    free(req);
+    return rc;
+}
+
+int read_at(struct client_connection *conn, void *buf, size_t count, off_t offset) {
+    return process_request(conn, buf, count, offset, TypeRead);
+}
+
+int write_at(struct client_connection *conn, void *buf, size_t count, off_t offset) {
+    return process_request(conn, buf, count, offset, TypeWrite);
+}
+
+struct client_connection *new_client_connection(char *socket_path) {
+    struct sockaddr_un addr;
+    int fd, rc;
+    struct client_connection *conn;
+
+    fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fd == -1) {
+        perror(""socket error"");
+        exit(EXIT_FAILURE);
+    }
+
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    if (strlen(socket_path) >= sizeof(addr.sun_path)) {
+        fprintf(stderr, ""socket path is too long, more than %zu characters\\n"", sizeof(addr.sun_path) - 1);
+        exit(EXIT_FAILURE);
+    }
+
+    strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
+
+    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+        perror(""connect error"");
+        close(fd);
+        exit(EXIT_FAILURE);
+    }
+
+    conn = malloc(sizeof(struct client_connection));
+    if (conn == NULL) {
+        perror(""cannot allocate memory for conn"");
+        close(fd);
+        return NULL;
+    }
+
+    conn->fd = fd;
+    conn->seq = 0;
+    conn->msg_table = NULL;
+
+    rc = pthread_mutex_init(&conn->mutex, NULL);
+    if (rc != 0) {
+        perror(""fail to init conn->mutex"");
+        free(conn);
+        close(fd);
+        exit(EXIT_FAILURE);
+    }
+
+    return conn;
+}
+
+int shutdown_client_connection(struct client_connection *conn) {
+    if (conn == NULL) return -EINVAL;
+    close(conn->fd);
+    pthread_mutex_destroy(&conn->mutex);
+    free(conn);
+    return 0;
+}
+
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <sys/mman.h>
+#include <time.h>
+#include <fcntl.h>
+#include <errno.h>
+
+struct sema_mutex_args_struct {
+    sem_t* id;
+    pthread_mutex_t* mutex;
+    int* status;
+    pthread_barrier_t* barr;
+};
+
+void* mutex_keeper(void* w_args) {
+    struct sema_mutex_args_struct* args = (struct sema_mutex_args_struct*)w_args;
+    pthread_mutex_t* pmutex = args->mutex;
+    int* status = args->status;
+    pthread_barrier_t* barr = args->barr;
+    struct timespec start;
+
+    while (*status != -1) {
+        pthread_barrier_wait(barr);
+        if (*status == -1) break;
+        pthread_mutex_lock(pmutex);
+        pthread_barrier_wait(barr);
+        clock_gettime(CLOCK_REALTIME, &start);
+        pthread_mutex_unlock(pmutex);
+    }
+    return NULL;
+}
+
+void* semaphore_keeper(void* w_args) {
+    struct sema_mutex_args_struct* args = (struct sema_mutex_args_struct*)w_args;
+    sem_t* id = args->id;
+    int* status = args->status;
+    pthread_barrier_t* barr = args->barr;
+    struct timespec start;
+
+    while (*status != -1) {
+        pthread_barrier_wait(barr);
+        if (*status == -1) break;
+        if (sem_wait(id) != 0) perror(""sem_wait child"");
+        pthread_barrier_wait(barr);
+        clock_gettime(CLOCK_REALTIME, &start);
+        if (sem_post(id) != 0) printf(""sem_post child"");
+    }
+    return NULL;
+}
+
+void semaphore_mutex_not_empty(int w_iterations, int w_drop_cache) {
+    printf(""\\nMEASURING SEMAPHORE AND MUTEX ACQUISITION TIME AFTER RELEASE\\n"");
+
+    struct timespec* start = mmap(NULL, sizeof(struct timespec), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+    struct timespec* finish = mmap(NULL, sizeof(struct timespec), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+    int* status = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+    
+    if (start == MAP_FAILED || finish == MAP_FAILED || status == MAP_FAILED) {
+        perror(""mmap"");
+        exit(1);
+    }
+
+    *status = 1;
+
+    sem_t* id;
+    sem_unlink(""releasesem"");
+
+    if ((id = sem_open(""releasesem"", O_CREAT | O_EXCL, 0600, 0)) == SEM_FAILED) {
+        perror(""sem_open"");
+        exit(1);
+    }
+
+    if (sem_post(id) != 0) printf(""sem_post failed"");
+
+    struct sema_mutex_args_struct args;
+    args.id = id;
+    args.status = status;
+    args.barr = malloc(sizeof(pthread_barrier_t));
+    pthread_barrier_init(args.barr, NULL, 2);
+
+    pthread_t thread_creation;
+    pthread_create(&thread_creation, NULL, semaphore_keeper, (void*)&args);
+
+    double totSemaphoreCached = 0.0;
+
+    for (int i = 0; i < w_iterations; i++) {
+        pthread_barrier_wait(args.barr);
+        pthread_barrier_wait(args.barr);
+        if (sem_wait(id) != 0) printf(""WAIT FAILED ON PARENT"");
+        clock_gettime(CLOCK_REALTIME, finish);
+
+        if (i >= (w_iterations / 5)) {
+            totSemaphoreCached += (finish->tv_nsec - start->tv_nsec);
+        }
+
+        if (sem_post(id) != 0) printf(""POST FAILED ON PARENT"");
+    }
+
+    *status = -1;
+    pthread_barrier_wait(args.barr);
+    pthread_join(thread_creation, NULL);
+
+    printf(""\\nCached\\t\\tmean semaphore acquisition time after release with %d samples: %f ns\\n"", w_iterations - (w_iterations / 5), totSemaphoreCached / (w_iterations - (w_iterations / 5)));
+
+    if (w_drop_cache) {
+        pthread_create(&thread_creation, NULL, semaphore_keeper, (void*)&args);
+        int noncache_iterations = w_iterations / 10;
+        double totSemaphoreUncached = 0.0;
+        *status = 1;
+
+        for (int i = 0; i < noncache_iterations; i++) {
+            pthread_barrier_wait(args.barr);
+            drop_cache();  // Assuming drop_cache() is defined elsewhere
+            pthread_barrier_wait(args.barr);
+            if (sem_wait(id) != 0) printf(""WAIT FAILED ON PARENT"");
+            clock_gettime(CLOCK_REALTIME, finish);
+            totSemaphoreUncached += (finish->tv_nsec - start->tv_nsec);
+            if (sem_post(id) != 0) printf(""POST FAILED ON PARENT"");
+        }
+
+        *status = -1;
+        pthread_barrier_wait(args.barr);
+        pthread_join(thread_creation, NULL);
+
+        printf(""Non-cached\\tmean semaphore acquisition time after release with %d samples: %f ns\\n"", noncache_iterations, totSemaphoreUncached / noncache_iterations);
+    }
+
+    sem_close(id);
+    sem_unlink(""releasesem"");
+
+    args.mutex = malloc(sizeof(pthread_mutex_t));
+    pthread_mutex_init(args.mutex, NULL);
+
+    *status = 1;
+    pthread_create(&thread_creation, NULL, mutex_keeper, (void*)&args);
+
+    double totMutexCached = 0.0;
+
+    for (int i = 0; i < w_iterations; i++) {
+        pthread_barrier_wait(args.barr);
+        pthread_barrier_wait(args.barr);
+        pthread_mutex_lock(args.mutex);
+        clock_gettime(CLOCK_REALTIME, finish);
+        if (i >= (w_iterations / 5)) {
+            totMutexCached += (finish->tv_nsec - start->tv_nsec);
+        }
+        pthread_mutex_unlock(args.mutex);
+    }
+
+    *status = -1;
+    pthread_barrier_wait(args.barr);
+    pthread_join(thread_creation, NULL);
+
+    printf(""\\nCached\\t\\tmean mutex acquisition time after release with %d samples: %f ns\\n"", w_iterations - (w_iterations / 5), totMutexCached / (w_iterations - (w_iterations / 5)));
+
+    if (w_drop_cache) {
+        *status = 1;
+        pthread_create(&thread_creation, NULL, mutex_keeper, (void*)&args);
+
+        int noncache_iterations = w_iterations / 10;
+        double totMutexUncached = 0.0;
+
+        for (int i = 0; i < noncache_iterations; i++) {
+            pthread_barrier_wait(args.barr);
+            drop_cache();
+            pthread_barrier_wait(args.barr);
+            pthread_mutex_lock(args.mutex);
+            clock_gettime(CLOCK_REALTIME, finish);
+            totMutexUncached += (finish->tv_nsec - start->tv_nsec);
+            pthread_mutex_unlock(args.mutex);
+        }
+
+        *status = -1;
+        pthread_barrier_wait(args.barr);
+        pthread_join(thread_creation, NULL);
+
+        printf(""Non-cached\\tmean mutex acquisition time after release with %d samples: %f ns\\n"", noncache_iterations, totMutexUncached / noncache_iterations);
+    }
+
+    pthread_mutex_destroy(args.mutex);
+    free(args.mutex);
+    pthread_barrier_destroy(args.barr);
+    free(args.barr);
+
+    munmap(status, sizeof(int));
+    munmap(start, sizeof(struct timespec));
+    munmap(finish, sizeof(struct timespec));
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <time.h>
+#include <stdbool.h>
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+static unsigned int seed0;
+static unsigned int seed1;
+static int have_init = 0;
+
+static int read_dev_random (void *buffer, size_t buffer_size)
+{
+  int fd;
+  ssize_t status = 0;
+
+  char *buffer_position;
+  size_t yet_to_read;
+
+  fd = open (""/dev/urandom"", O_RDONLY);
+  if (fd < 0)
+  {
+    perror (""open"");
+    return (-1);
+  }
+
+  buffer_position = (char *) buffer;
+  yet_to_read = buffer_size;
+
+  while (yet_to_read > 0)
+  {
+    status = read (fd, (void *) buffer_position, yet_to_read);
+    if (status < 0)
+    {
+      if (errno == EINTR)
+ continue;
+
+      fprintf (stderr, ""read_dev_random: read failed.\\n"");
+      break;
+    }
+
+    buffer_position += status;
+    yet_to_read -= (size_t) status;
+  }
+
+  close (fd);
+
+  if (status < 0)
+    return (-1);
+  return (0);
+}
+
+static void do_init (void)
+{
+  if (have_init)
+    return;
+
+  read_dev_random (&seed0, sizeof (seed0));
+  read_dev_random (&seed1, sizeof (seed1));
+  have_init = 1;
+}
+
+int sn_random_init (void)
+{
+  have_init = 0;
+  do_init ();
+
+  return (0);
+}
+
+int sn_random (void)
+{
+  int r0;
+  int r1;
+
+
+
+  do_init ();
+
+  r0 = rand_r (&seed0);
+  r1 = rand_r (&seed1);
+
+
+
+  return (r0 ^ r1);
+}
+
+int sn_true_random (void)
+{
+  int ret = 0;
+  int status;
+
+  status = read_dev_random (&ret, sizeof (ret));
+  if (status != 0)
+    return (sn_random ());
+
+  return (ret);
+}
+
+int sn_bounded_random (int min, int max)
+{
+  int range;
+  int rand;
+
+  if (min == max)
+    return (min);
+  else if (min > max)
+  {
+    range = min;
+    min = max;
+    max = range;
+  }
+
+  range = 1 + max - min;
+  rand = min + (int) (((double) range)
+      * (((double) sn_random ()) / (((double) 32767) + 1.0)));
+
+  assert (rand >= min);
+  assert (rand <= max);
+
+  return (rand);
+}
+
+double sn_double_random (void)
+{
+  return (((double) sn_random ()) / (((double) 32767) + 1.0));
+}
+# 7 ""os21.c"" 2
+# 1 ""pycparser/utils/fake_libc_include/sys/types.h"" 1
+# 8 ""os21.c"" 2
+# 1 ""pycparser/utils/fake_libc_include/sys/syscall.h"" 1
+# 9 ""os21.c"" 2
+
+
+pthread_mutex_t lock;
+pthread_mutex_t lock2;
+pthread_cond_t empty;
+pthread_cond_t full;
+
+
+struct item{
+        int val;
+        int sleeptime;
+};
+
+struct item * buffer;
+
+void * consumer(void *dummy)
+{
+
+        int * curitem = (int *)(dummy);
+        pid_t x = syscall(__NR_gettid);
+
+        while(1)
+        {
+  
+                fflush(stdout);
+                while(*curitem < 0){
+
+                        pthread_cond_wait(&empty, &lock);
+                }
+                sleep(buffer[*curitem].sleeptime);
+                printf(""(CONSUMER) My ID is %d and I ate the number %d in %d seconds\\n\\n"",x,buffer[*curitem].val, buffer[*curitem].sleeptime);
+                buffer[*curitem].val = 0;
+                buffer[*curitem].sleeptime = 0;
+                *curitem = *curitem - 1;
+
+
+                if(*curitem == 30){
+                        pthread_cond_signal(&full);
+                }
+
+        }
+        return 0;
+}
+void * producer(void *dummy)
+{
+        pthread_mutex_lock(&lock2);
+        int * curitem = (int *)(dummy);
+        pid_t x = syscall(__NR_gettid);
+        pthread_mutex_unlock(&lock2);
+        int i = 0;
+        while(1)
+        {
+                sleep(generate_rand(3,7));
+                fflush(stdout);
+                pthread_mutex_lock(&lock);
+
+                while(*curitem > 30){
+                        pthread_cond_wait(&full, &lock);
+                }
+
+                *curitem = *curitem + 1;
+                i = (int)generate_rand(0,10);
+                printf(""(PRODUCER) My ID is %d and I created the value %d\\n\\n"",x,i);
+                buffer[*curitem].val = i;
+                i = (int)generate_rand(2,9);
+                buffer[*curitem].sleeptime = i;
+                if(*curitem == 0){
+                    pthread_cond_signal(&empty);
+                }
+                pthread_mutex_unlock(&lock);
+        }
+
+        return 0;
+}
+
+int main(int argc, char **argv)
+{
+        int * curitem = malloc(sizeof(int));
+        int curthread = 0;
+        buffer = malloc(sizeof(struct item)*32);
+        *curitem = -1;
+        pthread_mutex_init(&lock, 0);
+        pthread_mutex_init(&lock2, 0);
+        pthread_cond_init(&full, 0);
+        pthread_cond_init(&empty, 0);
+        int threadcap = atoi(argv[1]);
+        pthread_t conthreads[threadcap];
+        pthread_t prod;
+        pthread_create(&prod, 0, producer, (void*)curitem);
+
+        for(; curthread < threadcap; curthread++)
+                pthread_create(&conthreads[curthread], 0, consumer, (void*)curitem);
+
+        pthread_join(prod, 0);
+
+        for(curthread = 0; curthread < threadcap; curthread++)
+                pthread_join(conthreads[curthread], 0);
+
+        return 0;
+}
+",1
+"#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <pthread.h>
+#include <linux/spi/spidev.h>
+#include <string.h>
+#include <errno.h>
+
+
+#define SPI_MODE SPI_MODE_0
+#define SPI_BITS_PER_WORD 8
+#define SPI_SPEED_HZ 500000
+#define SPI_DELAY 0
+#define FPGA_SPI_DEV ""/dev/spidev0.0""
+
+
+#define CMD_SERVO 0x01
+#define CMD_SPEED_ACC_SWITCH 0x02
+#define CMD_AS 0x03
+#define CMD_LED 0x04
+#define CMD_SPEED 0x05
+#define CMD_SPEEDPOLL 0x06
+#define CMD_SPEEDRAW 0x07
+#define SPI_PREAMBLE 0xAA
+
+
+#define HIGHBYTE(x) ((x) >> 8)
+#define LOWBYTE(x) ((x) & 0xFF)
+
+int fd;
+FILE *logfd = NULL;
+
+static uint8_t spi_mode = SPI_MODE;
+static uint8_t spi_bits = SPI_BITS_PER_WORD;
+static uint32_t spi_speed = SPI_SPEED_HZ;
+static uint16_t spi_delay = SPI_DELAY;
+
+pthread_mutex_t spi_mutex;
+
+int fpga_open() {
+    int ret;
+
+    pthread_mutex_init(&spi_mutex, NULL);
+
+    printf(""Will use SPI to send commands to FPGA\\n"");
+    printf(""SPI configuration:\\n"");
+    printf(""    + dev: %s\\n"", FPGA_SPI_DEV);
+    printf(""    + mode: %d\\n"", spi_mode);
+    printf(""    + bits per word: %d\\n"", spi_bits);
+    printf(""    + speed: %d Hz (%d KHz)\\n\\n"", spi_speed, spi_speed / 1000);
+
+    if ((fd = open(FPGA_SPI_DEV, O_RDWR)) < 0) {
+        perror(""E: fpga: spi: Failed to open dev"");
+        return -1;
+    }
+
+    if ((ret = ioctl(fd, SPI_IOC_WR_MODE, &spi_mode)) < 0) {
+        perror(""E: fpga: spi: can't set spi mode wr"");
+        return -1;
+    }
+
+    if ((ret = ioctl(fd, SPI_IOC_RD_MODE, &spi_mode)) < 0) {
+        perror(""E: fpga: spi: can't set spi mode rd"");
+        return -1;
+    }
+
+    if ((ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &spi_bits)) < 0) {
+        perror(""E: fpga: spi: can't set bits per word wr"");
+        return -1;
+    }
+
+    if ((ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &spi_bits)) < 0) {
+        perror(""E: fpga: spi: can't set bits per word rd"");
+        return -1;
+    }
+
+    if ((ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi_speed)) < 0) {
+        perror(""E: fpga: spi: can't set speed wr"");
+        return -1;
+    }
+
+    if ((ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &spi_speed)) < 0) {
+        perror(""E: fpga: spi: can't set speed rd"");
+        return -1;
+    }
+
+    if (fpga_logopen() < 0) {
+        fprintf(stderr, ""E: fpga: could not open log\\n"");
+        return -1;
+    }
+
+    return 0;
+}
+
+void fpga_close() {
+    if (fd >= 0) {
+        close(fd);
+    }
+    if (logfd) {
+        fclose(logfd);
+    }
+    pthread_mutex_destroy(&spi_mutex);
+}
+
+int fpga_logopen() {
+    logfd = fopen(""/tmp/ourlog"", ""a"");
+    if (!logfd) {
+        perror(""E: fpga: could not open log file"");
+        return -1;
+    }
+    fprintf(logfd, ""--------reopened--------\\n"");
+    return 0;
+}
+
+int spisend(unsigned char *rbuf, unsigned char *wbuf, int len) {
+    int ret;
+
+    pthread_mutex_lock(&spi_mutex);
+
+    struct spi_ioc_transfer tr = {
+        .tx_buf = (unsigned long)wbuf,
+        .rx_buf = (unsigned long)rbuf,
+        .len = len,
+        .delay_usecs = spi_delay,
+        .speed_hz = spi_speed,
+        .bits_per_word = spi_bits,
+    };
+
+    ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
+    if (ret < 1) {
+        perror(""E: fpga: can't send SPI message"");
+        pthread_mutex_unlock(&spi_mutex);
+        return -1;
+    }
+
+    pthread_mutex_unlock(&spi_mutex);
+    return ret;
+}
+
+
+
+void fpga_testservos() {
+    if (fpga_open() < 0) {
+        fprintf(stderr, ""E: FPGA: Could not open SPI to FPGA\\n"");
+        exit(EXIT_FAILURE);
+    }
+
+    printf(""Moving servo left\\n"");
+    fpga_setservo(1, 0);
+    sleep(2);
+
+    printf(""Moving servo centre\\n"");
+    fpga_setservo(1, 4000);
+    sleep(2);
+
+    printf(""Moving servo right\\n"");
+    fpga_setservo(1, 8000);
+    sleep(2);
+
+    printf(""Moving servo centre\\n"");
+    fpga_setservo(1, 4000);
+
+    fpga_close();
+}
+
+",0
+"#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <signal.h>
+
+
+extern void skynet_logger_error(int, const char *, ...);
+extern void skynet_logger_notice(int, const char *, ...);
+extern void skynet_malloc(size_t);
+extern void skynet_free(void *);
+extern void skynet_config_init(const char *);
+extern void skynet_config_int(const char *, const char *, int *);
+extern void skynet_config_string(const char *, const char *, char *, size_t);
+extern void skynet_mq_init();
+extern void skynet_service_init(const char *);
+extern void skynet_logger_init(unsigned, const char *);
+extern void skynet_timer_init();
+extern void skynet_socket_init();
+extern void skynet_service_create(const char *, unsigned, const char *, int);
+extern void skynet_service_releaseall();
+extern void skynet_socket_free();
+extern void skynet_config_free();
+extern void skynet_socket_exit();
+extern int skynet_socket_poll();
+extern int skynet_message_dispatch();
+extern void skynet_updatetime();
+
+struct monitor {
+    int count;
+    int sleep;
+    int quit;
+    pthread_t *pids;
+    pthread_cond_t cond;
+    pthread_mutex_t mutex;
+};
+
+static struct monitor *m = 0;
+
+void create_thread(pthread_t *thread, void *(*start_routine)(void *), void *arg) {
+    if (pthread_create(thread, 0, start_routine, arg)) {
+        skynet_logger_error(0, ""Create thread failed"");
+        exit(1);
+    }
+}
+
+void wakeup(struct monitor *m, int busy) {
+    pthread_mutex_lock(&m->mutex);
+    if (m->sleep >= m->count - busy) {
+        pthread_cond_signal(&m->cond);
+    }
+    pthread_mutex_unlock(&m->mutex);
+}
+
+void *thread_socket(void *p) {
+    struct monitor *m = p;
+    while (1) {
+        pthread_mutex_lock(&m->mutex);
+        if (m->quit) {
+            pthread_mutex_unlock(&m->mutex);
+            break;
+        }
+        pthread_mutex_unlock(&m->mutex);
+
+        int r = skynet_socket_poll();
+        if (r == 0)
+            break;
+        if (r < 0) {
+            continue;
+        }
+        wakeup(m, 0);
+    }
+    return 0;
+}
+
+void *thread_timer(void *p) {
+    struct monitor *m = p;
+    while (1) {
+        pthread_mutex_lock(&m->mutex);
+        if (m->quit) {
+            pthread_mutex_unlock(&m->mutex);
+            break;
+        }
+        pthread_mutex_unlock(&m->mutex);
+
+        skynet_updatetime();
+        wakeup(m, m->count - 1);
+        usleep(1000);
+    }
+    return 0;
+}
+
+void *thread_worker(void *p) {
+    struct monitor *m = p;
+    while (1) {
+        pthread_mutex_lock(&m->mutex);
+        if (m->quit) {
+            pthread_mutex_unlock(&m->mutex);
+            break;
+        }
+        pthread_mutex_unlock(&m->mutex);
+
+        if (skynet_message_dispatch()) {
+            pthread_mutex_lock(&m->mutex);
+            ++m->sleep;
+
+            if (!m->quit)
+                pthread_cond_wait(&m->cond, &m->mutex);
+            --m->sleep;
+            pthread_mutex_unlock(&m->mutex);
+        }
+    }
+    return 0;
+}
+
+void skynet_start(unsigned harbor, unsigned thread) {
+    unsigned i;
+
+    m = skynet_malloc(sizeof(*m));
+    memset(m, 0, sizeof(*m));
+    m->count = thread;
+    m->sleep = 0;
+    m->quit = 0;
+    m->pids = skynet_malloc(sizeof(*m->pids) * (thread + 2));
+
+    pthread_mutex_init(&m->mutex, 0);
+    pthread_cond_init(&m->cond, 0);
+
+    for (i = 0; i < thread; i++) {
+        create_thread(m->pids + i, thread_worker, m);
+    }
+    create_thread(m->pids + i, thread_timer, m);
+    create_thread(m->pids + i + 1, thread_socket, m);
+
+    skynet_logger_notice(0, ""skynet start, harbor:%u workers:%u"", harbor, thread);
+
+    for (i = 0; i < thread; i++) {
+        pthread_join(*(m->pids + i), 0);
+    }
+
+    skynet_logger_notice(0, ""skynet shutdown, harbor:%u"", harbor);
+
+    pthread_mutex_destroy(&m->mutex);
+    pthread_cond_destroy(&m->cond);
+    skynet_free(m->pids);
+    skynet_free(m);
+}
+
+void skynet_shutdown(int sig) {
+    skynet_logger_notice(0, ""recv signal:%d"", sig);
+
+    pthread_mutex_lock(&m->mutex);
+    m->quit = 1;
+    skynet_socket_exit();
+    pthread_cond_broadcast(&m->cond);
+    pthread_mutex_unlock(&m->mutex);
+}
+
+void skynet_coredump(int sig) {
+    skynet_shutdown(sig);
+    skynet_service_releaseall();
+
+    signal(sig, SIG_DFL);
+    raise(sig);
+}
+
+void skynet_signal_init() {
+    struct sigaction actTerminate;
+    actTerminate.sa_handler = skynet_shutdown;
+    sigemptyset(&actTerminate.sa_mask);
+    actTerminate.sa_flags = 0;
+    sigaction(SIGTERM, &actTerminate, 0);
+
+    struct sigaction actCoredump;
+    actCoredump.sa_handler = skynet_coredump;
+    sigemptyset(&actCoredump.sa_mask);
+    actCoredump.sa_flags = 0;
+    sigaction(SIGSEGV, &actCoredump, 0);
+    sigaction(SIGILL, &actCoredump, 0);
+    sigaction(SIGFPE, &actCoredump, 0);
+    sigaction(SIGABRT, &actCoredump, 0);
+
+    sigset_t bset, oset;
+    sigemptyset(&bset);
+    sigaddset(&bset, SIGINT);
+
+    pthread_sigmask(SIG_BLOCK, &bset, &oset);
+}
+
+int main(int argc, char *argv[]) {
+  
+
+    return 0;
+}
+
+",0