diff --git a/proj/intercept/Makefile b/proj/intercept/Makefile
index 6a1245c..34be243 100644
--- a/proj/intercept/Makefile
+++ b/proj/intercept/Makefile
@@ -1,6 +1,6 @@
 
 CC=gcc
-CFLAGS=-std=c99 -pedantic -Wall -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE -D_POSIX_C_SOURCE=200809L -g
+CFLAGS=-std=c99 -pedantic -Wall -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE -D_POSIX_C_SOURCE=200809L
 
 .PHONY: all clean
 all: default
diff --git a/proj/intercept/src/intercept.c b/proj/intercept/src/intercept.c
index 89606cb..92c111c 100644
--- a/proj/intercept/src/intercept.c
+++ b/proj/intercept/src/intercept.c
@@ -215,8 +215,8 @@ func_def(ssize_t, recvmsg)(int, struct msghdr *, int);
 #define flag_str(flags, name, buf) if (flags & name) strcat(buf, #name "|")
 
 #define ret_addr __builtin_return_address(0)
-#define ret_str ": %p (%s+%p%s%s)"
-#define ret_data ret_addr, info.dli_fname, (long)ret_addr - (long)info.dli_fbase, info.dli_sname ? ", " : "", info.dli_sname ? info.dli_sname : ""
+#define ret_str ": %p (%s+%p%s%s%s%s)"
+#define ret_data ret_addr, info.dli_fname, (long)ret_addr - (long)info.dli_fbase, info.dli_sname ? ", " : "", info.dli_sname ? info.dli_sname : "", get_file_line(src_file, (long)ret_addr - (long)info.dli_fbase, &info) != -1 ? ", " : "", src_file
 #define lib_idx (((long)info.dli_fbase >> 12) & 0xFFF)
 
 #define if_fail if (strncmp(msg_buf, "fail ", 5) == 0)
@@ -316,6 +316,18 @@ func_def(ssize_t, recvmsg)(int, struct msghdr *, int);
 
 #define if_error(err) if (strcmp(msg_buf + 5, #err) == 0) { errno = err; }
 
+struct line_debug_info {
+    long addr;
+    int line_num;
+    char filename[64];
+};
+
+struct obj_debug_info {
+    unsigned long addr;
+    int n_entries;
+    struct line_debug_info *entries;
+};
+
 static void set_errno(const char *name, const char *msg_buf) {
     char *end_ptr = NULL;
     long val = strtol(msg_buf + 5, &end_ptr, 0);
@@ -573,6 +585,7 @@ static int intercept = 0;
 static int verbosity = 0;
 static uint8_t func_flags[256];
 static uint8_t lib_flags[0x1000];
+static struct obj_debug_info line_info[16];
 
 static size_t msg_bytes(char *buf, size_t maxlen, size_t len, const char *str, int flags) {
     size_t offset = flags & 1 ? snprintf(buf, maxlen, "\"") : snprintf(buf, maxlen, "%p:\"", str);
@@ -838,6 +851,116 @@ static void fin(void) {
     mode = 0, intercept = 0;
 }
 
+static int get_file_line(char *buf, long rel_ret, Dl_info *info) {
+    buf[0] = 0;
+    const long idx = ((long)info->dli_fbase >> 12) & 0xFFF;
+    if (!(lib_flags[idx] & 2))
+        return -1;
+
+    for (int i = 0; i < 16; i++) {
+        if (line_info[i].addr != (long)info->dli_fbase)
+            continue;
+        for (int j = line_info[i].n_entries - 1; j >= 0; j--) {
+            struct line_debug_info *entry = &line_info[i].entries[j];
+            if (entry->addr < rel_ret) {
+                sprintf(buf, "%s:%i", entry->filename, entry->line_num);
+                return entry->line_num;
+            }
+        }
+    }
+
+    return -1;
+}
+
+static int iter_lib_debug(struct dl_phdr_info *info, size_t size, void *data) {
+    const long idx = ((long)info->dlpi_addr >> 12) & 0xFFF;
+    if (!lib_flags[idx]) return 0;
+
+    char name_buf[256] = "";
+    const char *name = info->dlpi_name;
+    if (name[0] == 0) {
+        if (readlink("/proc/self/exe", name_buf, sizeof(name_buf)) == -1)
+            return 0;
+        name = name_buf;
+    }
+
+    int fds[2];
+    __real_pipe(fds);
+    pid_t pid = __real_fork();
+    switch (pid) {
+        case -1:
+            return 0;
+        case 0:
+            // child
+            __real_close(fds[0]);  // close read end
+            __real_close(STDERR_FILENO);
+            __real_dup2(fds[1], STDOUT_FILENO);
+            __real_close(fds[1]);
+            __real_execle("/bin/readelf", "readelf", "--debug-dump=decodedline", name, NULL, NULL);
+        default:
+            // parent
+            __real_close(fds[1]);  // close write end
+    }
+
+    char state = 0;
+    char buf[1024];
+    char line[3][256] = {0};
+    int n = 0, n_entries = 0;
+    struct line_debug_info *entries = NULL;
+    for (ssize_t num = -2; (num != -1 && num != 0) || (num == -1 && errno == EINTR); num = __real_read(fds[0], buf, sizeof(buf))) {
+        for (int i = 0; i < num; i++) {
+            char ch = buf[i];
+            if (state == 0 && ch == 'S') {
+                state = 'S';
+            } else if (state == 'S' && ch == 't') {
+                state = 't';
+            } else if (state == 't' && ch == 'm') {
+                state = 'm';
+            } else if (state == 'm' && ch == 't') {
+                state = 'T';
+            } else if (state == 'T' && ch == '\n') {
+                state = 'A';
+            } else if (state == 'A' || state == 'B' || state == 'C') {
+                // file name | line number | starting address
+                if (ch == ' ') {
+                    if (n == 0)
+                        continue;
+                    state++;
+                    n = 0;
+                    continue;
+                }
+                line[state - 'A'][n++] = ch;
+                line[state - 'A'][n] = 0;
+            } else if (state == 'D' && ch == '\n') {
+                state = 'A';
+                long addr = strtol(line[2], NULL, 0);
+                long line_num = strtol(line[1], NULL, 0);
+                entries = __real_realloc(entries, ++n_entries * sizeof(struct line_debug_info));
+                entries[n_entries - 1].addr = addr;
+                entries[n_entries - 1].line_num = (int)line_num;
+                strncpy(entries[n_entries - 1].filename, line[0], sizeof(entries[n_entries - 1].filename));
+            }
+        }
+    }
+
+    while (__real_waitpid(pid, NULL, 0) == -1) {
+        if (errno != EINTR) return 0;
+    }
+
+    if (n_entries > 0) {
+        lib_flags[idx] |= 2;
+        for (int i = 0; i < 16; i++) {
+            if (line_info[i].addr != 0)
+                continue;
+            line_info[i].addr = info->dlpi_addr;
+            line_info[i].n_entries = n_entries;
+            line_info[i].entries = entries;
+        }
+    }
+
+    return 0;
+}
+
 static int iter_lib(struct dl_phdr_info *info, size_t size, void *data) {
     char *name1 = (char *)data;
     const char *name2 = info->dlpi_name;
@@ -989,12 +1112,16 @@ static void init(void) {
             dl_iterate_phdr(iter_lib, lib_names[i]);
         }
     }
+
+    memset(line_info, 0, sizeof(line_info));
+    dl_iterate_phdr(iter_lib_debug, NULL);
 }
 
 void *sym(malloc)(size_t size) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_malloc] || !lib_flags[lib_idx]) return __real_malloc(size);
+    char src_file[256];
     msg("malloc(%li)" ret_str, size, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1013,6 +1140,7 @@ void *sym(calloc)(size_t nmemb, size_t size) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_calloc] || !lib_flags[lib_idx]) return __real_calloc(nmemb, size);
+    char src_file[256];
     msg("calloc(%li, %li)" ret_str, nmemb, size, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1031,6 +1159,7 @@ void *sym(realloc)(void *ptr, size_t size) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_realloc] || !lib_flags[lib_idx]) return __real_realloc(ptr, size);
+    char src_file[256];
     msg("realloc(%p, %li)" ret_str, ptr, size, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1049,6 +1178,7 @@ void *sym(reallocarray)(void *ptr, size_t nmemb, size_t size) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_reallocarray] || !lib_flags[lib_idx]) return __real_reallocarray(ptr, nmemb, size);
+    char src_file[256];
     msg("reallocarray(%p, %li)" ret_str, ptr, size, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1067,6 +1197,7 @@ void sym(free)(void *ptr) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_free] || !lib_flags[lib_idx]) { __real_free(ptr); return; }
+    char src_file[256];
     msg("free(%p)" ret_str, ptr, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1083,6 +1214,7 @@ int sym(getopt)(const int argc, char *const argv[], const char *shortopts) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_getopt] || !lib_flags[lib_idx]) return __real_getopt(argc, argv, shortopts);
+    char src_file[256];
     msg("getopt(%i, %as, %es)" ret_str, argc, argc, argv, shortopts, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1103,6 +1235,7 @@ void sym(exit)(int status) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_exit] || !lib_flags[lib_idx]) __real_exit(status);
+    char src_file[256];
     msg("exit(%i)" ret_str, status, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1117,6 +1250,7 @@ ssize_t sym(read)(int fildes, void *buf, size_t nbyte) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_read] || !lib_flags[lib_idx]) return __real_read(fildes, buf, nbyte);
+    char src_file[256];
     msg("read(%i, %p, %i)" ret_str, fildes, buf, nbyte, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1141,6 +1275,7 @@ ssize_t sym(pread)(int fildes, void *buf, size_t nbyte, off_t offset) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_pread] || !lib_flags[lib_idx]) return __real_pread(fildes, buf, nbyte, offset);
+    char src_file[256];
     msg("pread(%i, %p, %i, %i)" ret_str, fildes, buf, nbyte, offset, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1165,6 +1300,7 @@ ssize_t sym(write)(int fildes, const void *buf, size_t nbyte) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_write] || !lib_flags[lib_idx]) return __real_write(fildes, buf, nbyte);
+    char src_file[256];
     msg("write(%i, %eb, %i)" ret_str, fildes, nbyte, buf, nbyte, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1185,6 +1321,7 @@ ssize_t sym(pwrite)(int fildes, const void *buf, size_t nbyte, off_t offset) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_pwrite] || !lib_flags[lib_idx]) return __real_pwrite(fildes, buf, nbyte, offset);
+    char src_file[256];
     msg("pwrite(%i, %eb, %i, %i)" ret_str, fildes, nbyte, buf, nbyte, offset, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1205,6 +1342,7 @@ int sym(close)(int fildes) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_close] || !lib_flags[lib_idx]) return __real_close(fildes);
+    char src_file[256];
     msg("close(%i)" ret_str, fildes, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1286,6 +1424,7 @@ int sym(sigaction)(int sig, const struct sigaction *restrict act, struct sigacti
         if (!verbosity) {
             msg("sigaction(%i:%s, %p:{}, %p)" ret_str, sig, sigstr, act, oact, ret_addr);
         } else {
+            char src_file[256];
             msg("sigaction(%i:%s, %p:{sa_flags: 0x%x:%s, %s: %p, sa_mask: [%s]}, %p)" ret_str, sig, sigstr, act, act->sa_flags, flgstr, name, ptr, maskstr, oact, ret_data);
         }
     } else {
@@ -1337,6 +1476,7 @@ int sym(sem_init)(sem_t *sem, int pshared, unsigned int value) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_init] || !lib_flags[lib_idx]) return __real_sem_init(sem, pshared, value);
+    char src_file[256];
     msg("sem_init(%p, %i, %u)" ret_str, sem, pshared, value, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1368,9 +1508,11 @@ sem_t *sym(sem_open)(const char *name, int oflag, ...) {
         value = va_arg(args, unsigned int);
         va_end(args);
         if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_open] || !lib_flags[lib_idx]) return __real_sem_open(name, oflag, mode_arg, value);
+        char src_file[256];
         msg("sem_open(%es, 0%o:%s, 0%03o, %u)" ret_str, name, oflag, ostr, mode_arg, value, ret_data);
     } else {
         if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_open] || !lib_flags[lib_idx]) return __real_sem_open(name, oflag);
+        char src_file[256];
         msg("sem_open(%es, 0%o:|%s)" ret_str, name, oflag, ostr, ret_data);
     }
 
@@ -1443,6 +1585,7 @@ int sym(sem_post)(sem_t *sem) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_post] || !lib_flags[lib_idx]) return __real_sem_post(sem);
+    char src_file[256];
     msg("sem_post(%p)" ret_str, sem, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1461,6 +1604,7 @@ int sym(sem_wait)(sem_t *sem) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_wait] || !lib_flags[lib_idx]) return __real_sem_wait(sem);
+    char src_file[256];
     msg("sem_wait(%p)" ret_str, sem, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1479,6 +1623,7 @@ int sym(sem_trywait)(sem_t *sem) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_trywait] || !lib_flags[lib_idx]) return __real_sem_trywait(sem);
+    char src_file[256];
     msg("sem_trywait(%p)" ret_str, sem, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1497,6 +1642,7 @@ int sym(sem_timedwait)(sem_t *restrict sem, const struct timespec *restrict abs_
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_timedwait] || !lib_flags[lib_idx]) return __real_sem_timedwait(sem, abs_timeout);
+    char src_file[256];
     msg("sem_timedwait(%p, %qt)" ret_str, sem, abs_timeout, ret_data);
     struct timespec overwrite;
     if (mode >= 4) {
@@ -1544,6 +1690,7 @@ int sym(sem_getvalue)(sem_t *restrict sem, int *restrict value) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_getvalue] || !lib_flags[lib_idx]) return __real_sem_getvalue(sem, value);
+    char src_file[256];
     msg("sem_getvalue(%p, %p)" ret_str, sem, value, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1566,6 +1713,7 @@ int sym(sem_close)(sem_t *sem) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_close] || !lib_flags[lib_idx]) return __real_sem_close(sem);
+    char src_file[256];
     msg("sem_close(%p)" ret_str, sem, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1584,6 +1732,7 @@ int sym(sem_unlink)(const char *name) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_unlink] || !lib_flags[lib_idx]) return __real_sem_unlink(name);
+    char src_file[256];
     msg("sem_unlink(%es)" ret_str, name, ret_data);
     char overwrite[BUFFER_SIZE];
     if (mode >= 4) {
@@ -1617,6 +1766,7 @@ int sym(sem_destroy)(sem_t *sem) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_sem_destroy] || !lib_flags[lib_idx]) return __real_sem_destroy(sem);
+    char src_file[256];
     msg("sem_destroy(%p)" ret_str, sem, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1643,6 +1793,7 @@ int sym(shm_open)(const char *name, int oflag, mode_t mode_arg) {
     flag_str(oflag, O_TRUNC, ostr);
     if (oflag & ~(O_RDONLY | O_RDWR | O_CREAT | O_EXCL | O_TRUNC)) strcat(ostr, "?|");
 
+    char src_file[256];
     msg("shm_open(%es, 0%o:%s, 0%03o)" ret_str, name, oflag, ostr, mode_arg, ret_data);
     char overwrite[BUFFER_SIZE];
     if (mode >= 4) {
@@ -1713,6 +1864,7 @@ int sym(shm_unlink)(const char *name) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_shm_unlink] || !lib_flags[lib_idx]) return __real_shm_unlink(name);
+    char src_file[256];
     msg("shm_unlink(%es)" ret_str, name, ret_data);
     char overwrite[BUFFER_SIZE];
     if (mode >= 4) {
@@ -1759,6 +1911,7 @@ void *sym(mmap)(void *addr, size_t len, int prot, int flags, int fildes, off_t o
     flag_str(prot, MAP_ANONYMOUS, fstr);
     if (prot & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS)) strcat(fstr, "?|");
 
+    char src_file[256];
     msg("mmap(%p, %i, 0x%x:%s, %0x%x:%s, %i, %i)" ret_str, addr, len, prot, pstr, flags, fstr, fildes, off, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1781,6 +1934,7 @@ int sym(munmap)(void *addr, size_t len) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_munmap] || !lib_flags[lib_idx]) return __real_munmap(addr, len);
+    char src_file[256];
     msg("munmap(%p, %i)" ret_str, addr, len, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1799,6 +1953,7 @@ int sym(ftruncate)(int fildes, off_t length) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_ftruncate] || !lib_flags[lib_idx]) return __real_ftruncate(fildes, length);
+    char src_file[256];
     msg("ftruncate(%i, %i)" ret_str, fildes, length, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1834,6 +1989,7 @@ pid_t sym(wait)(int *stat_loc) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_wait] || !lib_flags[lib_idx]) return __real_wait(stat_loc);
+    char src_file[256];
     msg("wait(%p)" ret_str, stat_loc, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1862,6 +2018,7 @@ pid_t sym(waitpid)(pid_t pid, int *stat_loc, int options) {
     flag_str(options, WUNTRACED, ostr);
     if (options & ~(WCONTINUED | WNOHANG | WUNTRACED)) strcat(ostr, "?|");
 
+    char src_file[256];
     msg("waitpid(%i, %p, 0x%x:%s)" ret_str, pid, stat_loc, options, ostr, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1906,6 +2063,7 @@ int sym(execl)(const char *pathname, const char *arg, ...) {
         arg_buf_ptr += msg_str(arg_buf_ptr, sizeof(arg_buf) - (arg_buf_ptr - arg_buf), arg_vec[i], 0);
     }
 
+    char src_file[256];
     msg("execl(%es, %es%s)" ret_str, pathname, arg, arg_buf, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1947,6 +2105,7 @@ int sym(execlp)(const char *file, const char *arg, ...) {
         arg_buf_ptr += msg_str(arg_buf_ptr, sizeof(arg_buf) - (arg_buf_ptr - arg_buf), arg_vec[i], 0);
     }
 
+    char src_file[256];
     msg("execlp(%es, %es%s)" ret_str, file, arg, arg_buf, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -1994,6 +2153,7 @@ int sym(execle)(const char *pathname, const char *arg, ...) {
     }
 
     int len = 0; for (len = 0; envp[len] != NULL; len++) {}
+    char src_file[256];
     msg("execle(%es, %es%s, %as)" ret_str, pathname, arg, arg_buf, len, envp, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2015,6 +2175,7 @@ int sym(execv)(const char *pathname, char *const argv[]) {
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_execv] || !lib_flags[lib_idx]) return __real_execv(pathname, argv);
     int len = 0; for (len = 0; argv[len] != NULL; len++) {}
+    char src_file[256];
     msg("execv(%es, %as)" ret_str, pathname, len, argv, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2036,6 +2197,7 @@ int sym(execvp)(const char *file, char *const argv[]) {
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_execvp] || !lib_flags[lib_idx]) return __real_execvp(file, argv);
     int len = 0; for (len = 0; argv[len] != NULL; len++) {}
+    char src_file[256];
     msg("execvp(%es, %as)" ret_str, file, len, argv, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2058,6 +2220,7 @@ int sym(execvpe)(const char *file, char *const argv[], char *const envp[]) {
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_execvpe] || !lib_flags[lib_idx]) return __real_execvpe(file, argv, envp);
     int len1 = 0; for (len1 = 0; argv[len1] != NULL; len1++) {}
     int len2 = 0; for (len2 = 0; envp[len2] != NULL; len2++) {}
+    char src_file[256];
     msg("execvpe(%es, %as, %as)" ret_str, file, len1, argv, len2, envp, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2080,6 +2243,7 @@ int sym(execve)(const char *pathname, char *const argv[], char *const envp[]) {
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_execve] || !lib_flags[lib_idx]) return __real_execve(pathname, argv, envp);
     int len1 = 0; for (len1 = 0; argv[len1] != NULL; len1++) {}
     int len2 = 0; for (len2 = 0; envp[len2] != NULL; len2++) {}
+    char src_file[256];
     msg("execve(%es, %as, %as)" ret_str, pathname, len1, argv, len2, envp, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2102,6 +2266,7 @@ int sym(fexecve)(int fd, char *const argv[], char *const envp[]) {
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_fexecve] || !lib_flags[lib_idx]) return __real_fexecve(fd, argv, envp);
     int len1 = 0; for (len1 = 0; argv[len1] != NULL; len1++) {}
     int len2 = 0; for (len2 = 0; envp[len2] != NULL; len2++) {}
+    char src_file[256];
     msg("fexecve(%i, %as, %as)" ret_str, fd, len1, argv, len2, envp, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2122,6 +2287,7 @@ int sym(pipe)(int fildes[2]) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_pipe] || !lib_flags[lib_idx]) return __real_pipe(fildes);
+    char src_file[256];
     msg("pipe(%p)" ret_str, fildes, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2142,6 +2308,7 @@ int sym(dup)(int oldfd) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_dup] || !lib_flags[lib_idx]) return __real_dup(oldfd);
+    char src_file[256];
     msg("dup(%i)" ret_str, oldfd, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2160,6 +2327,7 @@ int sym(dup2)(int oldfd, int newfd) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_dup2] || !lib_flags[lib_idx]) return __real_dup2(oldfd, newfd);
+    char src_file[256];
     msg("dup2(%i, %i)" ret_str, oldfd, newfd, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2181,6 +2349,7 @@ int sym(dup3)(int oldfd, int newfd, int flags) {
     char fstr[16] = "|";
     flag_str(flags, O_CLOEXEC, fstr);
     if (flags & ~(O_CLOEXEC)) strcat(fstr, "?|");
+    char src_file[256];
     msg("dup3(%i, %i, 0%o:%s)" ret_str, oldfd, newfd, flags, fstr, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2199,6 +2368,7 @@ int sym(socket)(int domain, int type, int protocol) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_socket] || !lib_flags[lib_idx]) return __real_socket(domain, type, protocol);
+    char src_file[256];
     msg("socket(%i:%s, %i:%s, %i)" ret_str, domain, getdomainstr(domain), type, getsocktype(type), protocol, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2219,6 +2389,7 @@ int sym(bind)(int sockfd, const struct sockaddr *address, socklen_t address_len)
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_bind] || !lib_flags[lib_idx]) return __real_bind(sockfd, address, address_len);
+    char src_file[256];
     msg("bind(%i, %qa, %i)" ret_str, sockfd, address_len, address, address_len, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2239,6 +2410,7 @@ int sym(listen)(int sockfd, int backlog) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_listen] || !lib_flags[lib_idx]) return __real_listen(sockfd, backlog);
+    char src_file[256];
     msg("listen(%i, %i)" ret_str, sockfd, backlog, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2257,6 +2429,7 @@ int sym(accept)(int sockfd, struct sockaddr *restrict address, socklen_t *restri
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_accept] || !lib_flags[lib_idx]) return __real_accept(sockfd, address, address_len);
+    char src_file[256];
     msg("accept(%i, %p, %p)" ret_str, sockfd, address, address_len, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2285,6 +2458,7 @@ int sym(connect)(int sockfd, const struct sockaddr *address, socklen_t address_l
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_connect] || !lib_flags[lib_idx]) return __real_connect(sockfd, address, address_len);
+    char src_file[256];
     msg("connect(%i, %qa, %i)" ret_str, sockfd, address_len, address, address_len, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2305,6 +2479,7 @@ int sym(getaddrinfo)(const char *restrict node, const char *restrict service, co
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_getaddrinfo] || !lib_flags[lib_idx]) return __real_getaddrinfo(node, service, hints, res);
+    char src_file[256];
     msg("getaddrinfo(%es, %es, %qi, %p)" ret_str, node, service, hints, res, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2366,6 +2541,7 @@ void sym(freeaddrinfo)(struct addrinfo *res) {
     init();
     Dl_info info;
     if (!dladdr(ret_addr, &info) || !func_flags[func_idx_freeaddrinfo] || !lib_flags[lib_idx]) { __real_freeaddrinfo(res); return; }
+    char src_file[256];
     msg("freeaddrinfo(%p)" ret_str, res, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2393,6 +2569,7 @@ ssize_t sym(send)(int sockfd, const void *buf, size_t length, int flags) {
     flag_str(flags, MSG_FASTOPEN, fstr);
     if (flags & ~(MSG_CONFIRM | MSG_DONTROUTE | MSG_DONTWAIT | MSG_EOR | MSG_MORE | MSG_NOSIGNAL | MSG_OOB | MSG_FASTOPEN)) strcat(fstr, "?|");
 
+    char src_file[256];
     msg("send(%i, %eb, %i, 0x%x:%s)" ret_str, sockfd, length, buf, length, flags, fstr, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2424,6 +2601,7 @@ ssize_t sym(sendto)(int sockfd, const void *buf, size_t size, int flags, const s
     flag_str(flags, MSG_FASTOPEN, fstr);
     if (flags & ~(MSG_CONFIRM | MSG_DONTROUTE | MSG_DONTWAIT | MSG_EOR | MSG_MORE | MSG_NOSIGNAL | MSG_OOB | MSG_FASTOPEN)) strcat(fstr, "?|");
 
+    char src_file[256];
     msg("sendto(%i, %eb, %i, 0x%x:%s, %qa, %i)" ret_str, sockfd, size, buf, size, flags, fstr, addrlen, dest_addr, addrlen, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2455,6 +2633,7 @@ ssize_t sym(sendmsg)(int sockfd, const struct msghdr *message, int flags) {
     flag_str(flags, MSG_FASTOPEN, fstr);
     if (flags & ~(MSG_CONFIRM | MSG_DONTROUTE | MSG_DONTWAIT | MSG_EOR | MSG_MORE | MSG_NOSIGNAL | MSG_OOB | MSG_FASTOPEN)) strcat(fstr, "?|");
 
+    char src_file[256];
     msg("sendmsg(%i, %qm, 0x%x:%s)" ret_str, sockfd, message, flags, fstr, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2484,6 +2663,7 @@ ssize_t sym(recv)(int sockfd, void *buf, size_t size, int flags) {
     flag_str(flags, MSG_WAITALL, fstr);
     if (flags & ~(MSG_DONTWAIT | MSG_ERRQUEUE | MSG_OOB | MSG_PEEK | MSG_TRUNC | MSG_WAITALL)) strcat(fstr, "?|");
 
+    char src_file[256];
     msg("recv(%i, %p, %i, 0x%x:%s)" ret_str, sockfd, buf, size, flags, fstr, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2517,6 +2697,7 @@ ssize_t sym(recvfrom)(int sockfd, void *restrict buf, size_t size, int flags, st
     flag_str(flags, MSG_WAITALL, fstr);
     if (flags & ~(MSG_DONTWAIT | MSG_ERRQUEUE | MSG_OOB | MSG_PEEK | MSG_TRUNC | MSG_WAITALL)) strcat(fstr, "?|");
 
+    char src_file[256];
     msg("recvfrom(%i, %p, %i, 0x%x:%s, %p, %p)" ret_str, sockfd, buf, size, flags, fstr, addrlen, src_addr, addrlen, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
@@ -2555,6 +2736,7 @@ ssize_t sym(recvmsg)(int sockfd, struct msghdr *message, int flags) {
     flag_str(flags, MSG_WAITALL, fstr);
     if (flags & ~(MSG_CMSG_CLOEXEC | MSG_DONTWAIT | MSG_ERRQUEUE | MSG_OOB | MSG_PEEK | MSG_TRUNC | MSG_WAITALL)) strcat(fstr, "?|");
 
+    char src_file[256];
     msg("recvmsg(%i, %qm, 0x%x:%s)" ret_str, sockfd, msg, flags, fstr, ret_data);
     if (mode >= 4) {
         char msg_buf[BUFFER_SIZE];
diff --git a/proj/test1/src/main.c b/proj/test1/src/main.c
index fd7427d..fa181b3 100644
--- a/proj/test1/src/main.c
+++ b/proj/test1/src/main.c
@@ -37,6 +37,14 @@ void do_sem(void) {
         }
     }
 
+    for (int i = 0; i < 8; i++) {
+        if (i & 1) {
+            sem_post(&sem);
+        } else {
+            sem_post(&sem);
+        }
+    }
+
     do_something();
 
     sem_wait(&sem);