diff --git a/exercises/04/PS4-recitaion.pdf b/exercises/04/PS4-recitaion.pdf
new file mode 100644
index 0000000..6e6766e
Binary files /dev/null and b/exercises/04/PS4-recitaion.pdf differ
diff --git a/exercises/04/PS4.pdf b/exercises/04/PS4.pdf
new file mode 100644
index 0000000..adb7567
Binary files /dev/null and b/exercises/04/PS4.pdf differ
diff --git a/exercises/04/ps4_skeleton.tar b/exercises/04/ps4_skeleton.tar
new file mode 100644
index 0000000..cd027ab
Binary files /dev/null and b/exercises/04/ps4_skeleton.tar differ
diff --git a/exercises/04/vslc/Makefile b/exercises/04/vslc/Makefile
new file mode 100644
index 0000000..c04ee65
--- /dev/null
+++ b/exercises/04/vslc/Makefile
@@ -0,0 +1,12 @@
+LEX=flex
+YACC=bison
+YFLAGS+=--defines=src/y.tab.h -o y.tab.c
+CFLAGS+=-std=c99 -g -Isrc -Iinclude -D_POSIX_C_SOURCE=200809L -DYYSTYPE="node_t *"
+
+src/vslc: src/vslc.c src/parser.o src/scanner.o src/nodetypes.o src/tree.o src/ir.o src/tlhash.c
+src/y.tab.h: src/parser.c
+src/scanner.c: src/y.tab.h src/scanner.l
+clean:
+	-rm -f src/parser.c src/scanner.c src/*.tab.* src/*.o
+purge: clean
+	-rm -f src/vslc
diff --git a/exercises/04/vslc/include/ir.h b/exercises/04/vslc/include/ir.h
new file mode 100644
index 0000000..78150e1
--- /dev/null
+++ b/exercises/04/vslc/include/ir.h
@@ -0,0 +1,30 @@
+#ifndef IR_H
+#define IR_H
+
+/* This is the tree node structure */
+typedef struct n {
+    node_index_t type;
+    void *data;
+    struct s *entry;
+    uint64_t n_children;
+    struct n **children;
+} node_t;
+
+// Export the initializer function, it is needed by the parser
+void node_init (
+    node_t *nd, node_index_t type, void *data, uint64_t n_children, ...
+);
+
+typedef enum {
+    SYM_GLOBAL_VAR, SYM_FUNCTION, SYM_PARAMETER, SYM_LOCAL_VAR
+} symtype_t;
+
+typedef struct s {
+    char *name;
+    symtype_t type;
+    node_t *node;
+    size_t seq;
+    size_t nparms;
+    tlhash_t *locals;
+} symbol_t;
+#endif
diff --git a/exercises/04/vslc/include/nodetypes.h b/exercises/04/vslc/include/nodetypes.h
new file mode 100644
index 0000000..5d302cc
--- /dev/null
+++ b/exercises/04/vslc/include/nodetypes.h
@@ -0,0 +1,37 @@
+#ifndef NODETYPES_H
+#define NODETYPES_H
+typedef enum {
+    PROGRAM,
+    GLOBAL_LIST,
+    GLOBAL,
+    STATEMENT_LIST,
+    PRINT_LIST,
+    EXPRESSION_LIST,
+    VARIABLE_LIST,
+    ARGUMENT_LIST,
+    PARAMETER_LIST,
+    DECLARATION_LIST,
+    FUNCTION,
+    STATEMENT,
+    BLOCK,
+    ASSIGNMENT_STATEMENT,
+    ADD_STATEMENT,
+    SUBTRACT_STATEMENT,
+    MULTIPLY_STATEMENT,
+    DIVIDE_STATEMENT,
+    RETURN_STATEMENT,
+    PRINT_STATEMENT,
+    NULL_STATEMENT,
+    IF_STATEMENT,
+    WHILE_STATEMENT,
+    EXPRESSION,
+    RELATION,
+    DECLARATION,
+    PRINT_ITEM,
+    IDENTIFIER_DATA,
+    NUMBER_DATA,
+    STRING_DATA
+} node_index_t;
+
+extern char *node_string[26];
+#endif
diff --git a/exercises/04/vslc/include/tlhash.h b/exercises/04/vslc/include/tlhash.h
new file mode 100644
index 0000000..889e535
--- /dev/null
+++ b/exercises/04/vslc/include/tlhash.h
@@ -0,0 +1,28 @@
+#ifndef TLHASH_H
+#define TLHASH_H
+#include <stddef.h>
+typedef struct el {
+    void *key, *value;
+    size_t key_length;
+    struct el *next;
+} tlhash_element_t;
+
+typedef struct {
+    size_t n_buckets, size;
+    tlhash_element_t **buckets;
+} tlhash_t;
+
+int tlhash_init ( tlhash_t *tab, size_t n_buckets );
+int tlhash_finalize ( tlhash_t *tab );
+int tlhash_insert ( tlhash_t *tab, void *key, size_t keylen, void *val );
+int tlhash_lookup ( tlhash_t *tab, void *key, size_t keylen, void **val );
+int tlhash_remove ( tlhash_t *tab, void *key, size_t key_length );
+size_t tlhash_size ( tlhash_t *tab );
+void tlhash_keys ( tlhash_t *tab, void **keys );
+void tlhash_values ( tlhash_t *tab, void **values );
+
+#define TLHASH_SUCCESS 0    /* Success */
+#define TLHASH_ENOMEM 1     /* No memory available */
+#define TLHASH_ENOENT 2     /* No such table entry */
+#define TLHASH_EEXIST 3     /* Table entry already exists */
+#endif
diff --git a/exercises/04/vslc/include/vslc.h b/exercises/04/vslc/include/vslc.h
new file mode 100644
index 0000000..35403d1
--- /dev/null
+++ b/exercises/04/vslc/include/vslc.h
@@ -0,0 +1,48 @@
+#ifndef VSLC_H
+#define VSLC_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+
+// Prototypes for the hash table functions
+#include "tlhash.h"
+
+// Numbers and names for the types of syntax tree nodes
+#include "nodetypes.h"
+
+// Definition of the tree node type
+#include "ir.h"
+
+// Token definitions and other things from bison, needs def. of node type
+#include "y.tab.h"
+
+/* This is generated from the bison grammar, calls on the flex specification */
+int yyerror ( const char *error );
+
+/* These are defined in the parser generated by bison */
+extern int yylineno;
+extern int yylex ( void );
+extern char yytext[];
+
+/* Global state */
+extern node_t *root;
+
+// Moving global defs to global header
+
+extern tlhash_t *global_names;  // Defined in ir.c, used by generator.c
+extern char **string_list;      // Defined in ir.c, used by generator.c
+extern size_t stringc;          // Defined in ir.c, used by generator.c
+
+/* Global routines, called from main in vslc.c */
+void simplify_syntax_tree ( void );
+void print_syntax_tree ( void );
+void destroy_syntax_tree ( void );
+
+void create_symbol_table ( void );
+void print_symbol_table ( void );
+void destroy_symbol_table ( void );
+
+#endif
diff --git a/exercises/04/vslc/src/ir.c b/exercises/04/vslc/src/ir.c
new file mode 100644
index 0000000..6971119
--- /dev/null
+++ b/exercises/04/vslc/src/ir.c
@@ -0,0 +1,76 @@
+#include <vslc.h>
+
+// Externally visible, for the generator
+extern tlhash_t *global_names;
+extern char **string_list;
+extern size_t n_string_list, stringc;
+
+// Implementation choices, only relevant internally
+static void find_globals ( void );
+/** @param function Function's symbol table entry
+ *  @param root Function's root node */
+static void bind_names ( symbol_t *function, node_t *root );
+
+void
+create_symbol_table ( void )
+{
+    /* TODO: traverse the syntax tree and create the symbol table */
+
+    // ! Example code solely to demonstrate usage of tlhash. Make sure to remove
+    // ! or comment this out when implementing your solution.
+
+    // Initialize table
+    tlhash_t *my_table = (tlhash_t*)malloc(sizeof(tlhash_t));
+    tlhash_init(my_table, 64);
+
+    char *my_key0 = "key";    // Keep in mind that these are stack allocated for simplicity, yours should not
+    char *my_val0 = "valuable"; // Also, I'm using strings as values, you will be using symbol_t pointers
+    char *my_key1 = "another_key";
+    char *my_val1 = "more valuable";
+    
+    // Insert some values to the table. Remember that the length of a string
+    // interpreted as an array is the string length plus one '\0' character
+    tlhash_insert(my_table, my_key0, strlen(my_key0)+1, my_val0);
+    tlhash_insert(my_table, my_key1, strlen(my_key1)+1, my_val1);
+
+    // Iterate keys and lookup their values
+    size_t size = tlhash_size(my_table);
+    char **keys = (char **)malloc(size);
+    tlhash_keys(my_table, keys);
+    char *val;
+    for (int i = 0; i < size; i++) {
+        tlhash_lookup(my_table, keys[i], strlen(keys[i])+1, &val);
+        printf("my_table[%s] = \"%s\"\n", keys[i], val);
+    }
+
+    // Free allocated memory when done with the symbol table
+    tlhash_finalize(my_table);
+    free(my_table);
+    free(keys);
+}
+
+
+void
+print_symbol_table ( void )
+{
+    /* TODO: output its contents */
+}
+
+void
+destroy_symbol_table ( void )
+{
+    /* TODO: release memory allocated to the symbol table */
+}
+
+void
+find_globals ( void )
+{
+    /* TODO: Populate symbol table with global variables and functions */
+}
+
+
+void 
+bind_names ( symbol_t *function, node_t *root )
+{
+    /* TODO: Bind names and string literals in local symbol table */
+}
diff --git a/exercises/04/vslc/src/nodetypes.c b/exercises/04/vslc/src/nodetypes.c
new file mode 100644
index 0000000..dd90315
--- /dev/null
+++ b/exercises/04/vslc/src/nodetypes.c
@@ -0,0 +1,34 @@
+#define STRING(x) #x
+char *node_string[30] = {
+    STRING(PROGRAM),
+    STRING(GLOBAL_LIST),
+    STRING(GLOBAL),
+    STRING(STATEMENT_LIST),
+    STRING(PRINT_LIST),
+    STRING(EXPRESSION_LIST),
+    STRING(VARIABLE_LIST),
+    STRING(ARGUMENT_LIST),
+    STRING(PARAMETER_LIST),
+    STRING(DECLARATION_LIST),
+    STRING(FUNCTION),
+    STRING(STATEMENT),
+    STRING(BLOCK),
+    STRING(ASSIGNMENT_STATEMENT),
+    STRING(ADD_STATEMENT),
+    STRING(SUBTRACT_STATEMENT),
+    STRING(MULTIPLY_STATEMENT),
+    STRING(DIVIDE_STATEMENT),
+    STRING(RETURN_STATEMENT),
+    STRING(PRINT_STATEMENT),
+    STRING(NULL_STATEMENT),
+    STRING(IF_STATEMENT),
+    STRING(WHILE_STATEMENT),
+    STRING(EXPRESSION),
+    STRING(RELATION),
+    STRING(DECLARATION),
+    STRING(PRINT_ITEM),
+    STRING(IDENTIFIER_DATA),
+    STRING(NUMBER_DATA),
+    STRING(STRING_DATA)
+};
+#undef STRING
diff --git a/exercises/04/vslc/src/parser.y b/exercises/04/vslc/src/parser.y
new file mode 100644
index 0000000..f1abcc8
--- /dev/null
+++ b/exercises/04/vslc/src/parser.y
@@ -0,0 +1,181 @@
+%{
+#include <vslc.h>
+
+#define N0C(n,t,d) do { \
+    node_init ( n = malloc(sizeof(node_t)), t, d, 0 ); \
+} while ( false )
+#define N1C(n,t,d,a) do { \
+    node_init ( n = malloc(sizeof(node_t)), t, d, 1, a ); \
+} while ( false )
+#define N2C(n,t,d,a,b) do { \
+    node_init ( n = malloc(sizeof(node_t)), t, d, 2, a, b ); \
+} while ( false )
+#define N3C(n,t,d,a,b,c) do { \
+    node_init ( n = malloc(sizeof(node_t)), t, d, 3, a, b, c ); \
+} while ( false )
+
+%}
+
+%left '|'
+%left '^'
+%left '&'
+%left '+' '-'
+%left '*' '/'
+%nonassoc UMINUS
+%right '~'
+%expect 1
+
+%token FUNC PRINT RETURN CONTINUE IF THEN ELSE WHILE DO OPENBLOCK CLOSEBLOCK
+%token VAR NUMBER IDENTIFIER STRING
+
+%%
+program :
+      global_list { N1C ( root, PROGRAM, NULL, $1 ); }
+    ;
+global_list :
+      global { N1C ( $$, GLOBAL_LIST, NULL, $1 ); }
+    | global_list global { N2C ( $$, GLOBAL_LIST, NULL, $1, $2 ); }
+    ;
+global:
+      function { N1C ( $$, GLOBAL, NULL, $1 ); }
+    | declaration { N1C ( $$, GLOBAL, NULL, $1 ); }
+    ;
+statement_list :
+      statement { N1C ( $$, STATEMENT_LIST, NULL, $1 ); }
+    | statement_list statement { N2C ( $$, STATEMENT_LIST, NULL, $1, $2 ); }
+    ;
+print_list :
+      print_item { N1C ( $$, PRINT_LIST, NULL, $1 ); }
+    | print_list ',' print_item { N2C ( $$, PRINT_LIST, NULL, $1, $3 ); }
+    ;
+expression_list :
+      expression { N1C ( $$, EXPRESSION_LIST, NULL, $1 ); }
+    | expression_list ',' expression { N2C($$, EXPRESSION_LIST, NULL, $1, $3); }
+    ;
+variable_list :
+      identifier { N1C ( $$, VARIABLE_LIST, NULL, $1 ); }
+    | variable_list ',' identifier { N2C ( $$, VARIABLE_LIST, NULL, $1, $3 ); }
+    ;
+argument_list :
+      expression_list { N1C ( $$, ARGUMENT_LIST, NULL, $1 ); }
+    | /* epsilon */ { $$ = NULL; }
+    ;
+parameter_list :
+      variable_list { N1C ( $$, PARAMETER_LIST, NULL, $1 ); }
+    | /* epsilon */ { $$ = NULL; }
+    ;
+declaration_list :
+      declaration { N1C ( $$, DECLARATION_LIST, NULL, $1 ); }
+    | declaration_list declaration { N2C ($$, DECLARATION_LIST, NULL, $1, $2); }
+    ;
+function :
+      FUNC identifier '(' parameter_list ')' statement
+        { N3C ( $$, FUNCTION, NULL, $2, $4, $6 ); }
+    ;
+statement :
+      assignment_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
+    | return_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
+    | print_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
+    | if_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
+    | while_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
+    | null_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
+    | block { N1C ( $$, STATEMENT, NULL, $1 ); }
+    ;
+block :
+      OPENBLOCK declaration_list statement_list CLOSEBLOCK
+        { N2C ($$, BLOCK, NULL, $2, $3); }
+    | OPENBLOCK statement_list CLOSEBLOCK { N1C ($$, BLOCK, NULL, $2 ); }
+    ;
+assignment_statement :
+      identifier ':' '=' expression
+        { N2C ( $$, ASSIGNMENT_STATEMENT, NULL, $1, $4 ); }
+    | identifier '+' '=' expression
+        { N2C ( $$, ADD_STATEMENT, NULL, $1, $4 ); }
+    | identifier '-' '=' expression
+        { N2C ( $$, SUBTRACT_STATEMENT, NULL, $1, $4 ); }
+    | identifier '*' '=' expression
+        { N2C ( $$, MULTIPLY_STATEMENT, NULL, $1, $4 ); }
+    | identifier '/' '=' expression
+        { N2C ( $$, DIVIDE_STATEMENT, NULL, $1, $4 ); }
+    ;
+return_statement :
+      RETURN expression
+        { N1C ( $$, RETURN_STATEMENT, NULL, $2 ); }
+    ;
+print_statement :
+      PRINT print_list
+        { N1C ( $$, PRINT_STATEMENT, NULL, $2 ); }
+    ;
+null_statement :
+      CONTINUE
+        { N0C ( $$, NULL_STATEMENT, NULL ); }
+    ;
+if_statement :
+      IF relation THEN statement
+        { N2C ( $$, IF_STATEMENT, NULL, $2, $4 ); }
+    | IF relation THEN statement ELSE statement
+        { N3C ( $$, IF_STATEMENT, NULL, $2, $4, $6 ); }
+    ;
+while_statement :
+      WHILE relation DO statement
+        { N2C ( $$, WHILE_STATEMENT, NULL, $2, $4 ); }
+    ;
+relation:
+      expression '=' expression
+        { N2C ( $$, RELATION, strdup("="), $1, $3 ); }
+    | expression '<' expression
+        { N2C ( $$, RELATION, strdup("<"), $1, $3 ); }
+    | expression '>' expression
+        { N2C ( $$, RELATION, strdup(">"), $1, $3 ); }
+    ;
+expression :
+      expression '|' expression
+        { N2C ( $$, EXPRESSION, strdup("|"), $1, $3 ); }
+    | expression '^' expression
+        { N2C ( $$, EXPRESSION, strdup("^"), $1, $3 ); }
+    | expression '&' expression
+        { N2C ( $$, EXPRESSION, strdup("&"), $1, $3 ); }
+    | expression '+' expression
+        { N2C ( $$, EXPRESSION, strdup("+"), $1, $3 ); }
+    | expression '-' expression
+        { N2C ( $$, EXPRESSION, strdup("-"), $1, $3 ); }
+    | expression '*' expression
+        { N2C ( $$, EXPRESSION, strdup("*"), $1, $3 ); }
+    | expression '/' expression
+        { N2C ( $$, EXPRESSION, strdup("/"), $1, $3 ); }
+    | '-' expression %prec UMINUS
+        { N1C ( $$, EXPRESSION, strdup("-"), $2 ); }
+    | '~' expression %prec UMINUS
+        { N1C ( $$, EXPRESSION, strdup("~"), $2 ); }
+    | '(' expression ')' { $$ = $2; }
+    | number { N1C ( $$, EXPRESSION, NULL, $1 ); }
+    | identifier
+        { N1C ( $$, EXPRESSION, NULL, $1 ); }
+    | identifier '(' argument_list ')'
+        { N2C ( $$, EXPRESSION, NULL, $1, $3 ); }
+    ;
+declaration :
+      VAR variable_list { N1C ( $$, DECLARATION, NULL, $2 ); }
+    ;
+print_item :
+      expression
+        { N1C ( $$, PRINT_ITEM, NULL, $1 ); }
+    | string
+        { N1C ( $$, PRINT_ITEM, NULL, $1 ); }
+    ;
+identifier: IDENTIFIER { N0C($$, IDENTIFIER_DATA, strdup(yytext) ); }
+number: NUMBER
+      {
+        int64_t *value = malloc ( sizeof(int64_t) );
+        *value = strtol ( yytext, NULL, 10 );
+        N0C($$, NUMBER_DATA, value );
+      }
+string: STRING { N0C($$, STRING_DATA, strdup(yytext) ); }
+%%
+
+int
+yyerror ( const char *error )
+{
+    fprintf ( stderr, "%s on line %d\n", error, yylineno );
+    exit ( EXIT_FAILURE );
+}
diff --git a/exercises/04/vslc/src/scanner.l b/exercises/04/vslc/src/scanner.l
new file mode 100644
index 0000000..ffa93ff
--- /dev/null
+++ b/exercises/04/vslc/src/scanner.l
@@ -0,0 +1,30 @@
+%{
+#include <vslc.h>
+%}
+%option noyywrap
+%option array
+%option yylineno
+
+WHITESPACE [\ \t\v\r\n]
+COMMENT \/\/[^\n]+
+QUOTED \"([^\"\n]|\\\")*\"
+%%
+{WHITESPACE}+           { /* Eliminate whitespace */ }
+{COMMENT}               { /* Eliminate comments */ }
+func                    { return FUNC; }
+print                   { return PRINT; }
+return                  { return RETURN; }
+continue                { return CONTINUE; }
+if                      { return IF; }
+then                    { return THEN; }
+else                    { return ELSE; }
+while                   { return WHILE; }
+do                      { return DO; }
+begin                   { return OPENBLOCK; }
+end                     { return CLOSEBLOCK; }
+var                     { return VAR; }
+[0-9]+                  { return NUMBER; }
+[A-Za-z_][0-9A-Za-z_]*  { return IDENTIFIER; }
+{QUOTED}                { return STRING; }
+.                       { return yytext[0]; }
+%%
diff --git a/exercises/04/vslc/src/tlhash.c b/exercises/04/vslc/src/tlhash.c
new file mode 100644
index 0000000..7936ece
--- /dev/null
+++ b/exercises/04/vslc/src/tlhash.c
@@ -0,0 +1,281 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include <tlhash.h>
+
+/*********************************************************************
+ * Declarations of the utility functions for obtaining hashes, found *
+ * at the bottom of this file.                                       *
+ *********************************************************************/
+
+/* Little-endian, for x86-s */
+#define CRC32_IEEE802_3 (0xedb88320)
+static const uint32_t crc32_ieee802_3[256];
+static const uint32_t *crc_table = (uint32_t *)crc32_ieee802_3;
+
+static uint32_t crc32 ( void *input, size_t length );
+
+
+/********************************
+ * External interface functions *
+ ********************************/
+
+
+/* Initializer 
+ * Returns
+ *  ENOMEM - if allocation of table entries fails.
+ */
+int
+tlhash_init ( tlhash_t *tab, size_t n_buckets )
+{
+    size_t i;
+    tab->n_buckets = n_buckets;
+    tab->size = 0;
+    tab->buckets = (tlhash_element_t **) calloc (
+        n_buckets, sizeof(tlhash_element_t *)
+    );
+    if ( tab->buckets == NULL )
+        return TLHASH_ENOMEM;
+    for ( i=0; i<n_buckets; i++ )
+        tab->buckets[i] = NULL;
+    return TLHASH_SUCCESS;
+}
+
+
+/* Finalizer
+ * Returns
+ *  ENOENT - if there is no table to free.
+ */
+int
+tlhash_finalize ( tlhash_t *tab )
+{
+    size_t i;
+    if ( tab == NULL )
+        return TLHASH_ENOENT;
+    for ( i=0; i<tab->n_buckets; i++ )
+    {
+        tlhash_element_t *element = tab->buckets[i], *next;
+        while ( element != NULL )
+        {
+            next = element->next;
+            free ( element->key );
+            free ( element );
+            tab->size -= 1;
+            element = next;
+        }
+    }
+
+    free ( tab->buckets );
+    return TLHASH_SUCCESS;
+}
+
+
+/* Insert - find hash value, modulate over buckets, append to linked list
+ * Returns
+ *  EEXIST - if an element is already indexed by this key
+ *  ENOMEM - if allocation of element or key copy fails
+ */
+int
+tlhash_insert (
+    tlhash_t *tab, void *key, size_t key_length, void *value
+)
+{
+    void *test_entry;
+    int test = tlhash_lookup ( tab, key, key_length, &test_entry );
+    if ( test != TLHASH_ENOENT )
+        return TLHASH_EEXIST;
+    uint32_t hash = crc32 ( key, key_length );
+    size_t bucket = hash % tab->n_buckets;
+    tlhash_element_t *element = malloc ( sizeof(tlhash_element_t) );
+    if ( element == NULL )
+        return TLHASH_ENOMEM;
+    void *key_copy = malloc ( key_length );
+    if ( key_copy == NULL )
+    {
+        free ( element );
+        return TLHASH_ENOMEM;
+    }
+    memcpy ( key_copy, key, key_length );
+    element->key         = key_copy;
+    element->key_length  = key_length;
+    element->value       = value;
+    element->next        = tab->buckets[bucket];
+    tab->buckets[bucket] = element;
+    tab->size += 1;
+    return TLHASH_SUCCESS;
+}
+
+
+/* Lookup - find hash value, modulate over buckets, search linked list
+ * Returns
+ *  ENOENT - if no element is indexed by this key
+ */
+int
+tlhash_lookup (
+    tlhash_t *tab, void *key, size_t key_length, void **value
+)
+{
+    uint32_t hash = crc32 ( key, key_length );
+    size_t bucket = hash % tab->n_buckets;
+    tlhash_element_t *el = tab->buckets[bucket];
+
+    *value = NULL;
+    while ( el != NULL )
+    {
+        if ( el->key_length == key_length && ! memcmp(el->key,key,key_length) )
+        {
+            *value = el->value;
+            break;
+        }
+        el = el->next;
+    }
+    if ( el != NULL )
+        return TLHASH_SUCCESS;
+    else
+        return TLHASH_ENOENT;
+}
+
+
+/* Removal - find hash value, modulate over buckets, delete entry
+ * Returns
+ *  ENOENT - no such element to remove was found.
+ */
+int
+tlhash_remove ( tlhash_t *tab, void *key, size_t key_length )
+{
+    uint32_t hash = crc32 ( key, key_length );
+    size_t bucket = hash % tab->n_buckets;
+    tlhash_element_t *el = tab->buckets[bucket], *prev = NULL;
+
+    while ( el != NULL )
+    {
+        if ( el->key_length == key_length && ! memcmp(el->key,key,key_length) )
+        {
+            /* We have a match. */
+            if ( prev != NULL ) /* Remove from list if it's not the head */
+                prev->next = (void *)el->next;
+            else                /* Substitute it if it IS the head */
+                tab->buckets[bucket] = el->next;
+            /* Free the container and key copy allocated by this lib */
+            free ( el->key );
+            free ( el );
+            break;
+        }
+        prev = el;
+        el = el->next;
+    }
+    if ( el == NULL )
+        return TLHASH_ENOENT;
+    else
+    {
+        tab->size -= 1;
+        return TLHASH_SUCCESS;
+    }
+}
+
+
+size_t
+tlhash_size ( tlhash_t *tab )
+{
+    return tab->size;
+}
+
+
+void
+tlhash_keys ( tlhash_t *tab, void **keys )
+{
+    size_t b, i = 0;
+    for ( b=0; b<tab->n_buckets; b++ )
+    {
+        tlhash_element_t *el = tab->buckets[b];
+        while ( el != NULL )
+        {
+            keys[i] = el->key;
+            i += 1;
+            el = el->next;
+        }
+    }
+}
+
+
+void
+tlhash_values ( tlhash_t *tab, void **values )
+{
+    size_t b, i = 0;
+    for ( b=0; b<tab->n_buckets; b++ )
+    {
+        tlhash_element_t *el = tab->buckets[b];
+        while ( el != NULL )
+        {
+            values[i] = el->value;
+            i += 1;
+            el = el->next;
+        }
+    }
+}
+
+
+/***************************************
+ * Hashing function and IEEE data blob *
+ ***************************************/
+
+
+static uint32_t
+crc32 ( void *input, size_t length )
+{
+    const uint8_t *data = (uint8_t *)input;
+    size_t i = 0;
+    uint32_t hash = 0xFFFFFFFF;
+    for ( i = 0; i<length; i++ )
+        hash = (hash>>8) ^ crc_table [ data[i] ^ (uint8_t)hash ];
+    return (hash^0xFFFFFFFF);
+}
+
+
+static const uint32_t
+crc32_ieee802_3[256] = {
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
diff --git a/exercises/04/vslc/src/tree.c b/exercises/04/vslc/src/tree.c
new file mode 100644
index 0000000..ef7658c
--- /dev/null
+++ b/exercises/04/vslc/src/tree.c
@@ -0,0 +1,232 @@
+#include <vslc.h>
+
+static void node_print ( node_t *root, int nesting );
+static void simplify_tree ( node_t **simplified, node_t *root );
+static void node_finalize ( node_t *discard );
+
+typedef struct stem_t *stem;
+struct stem_t { const char *str; stem next; };
+static void
+tree_print(node_t* root, stem head);
+
+
+static void destroy_subtree ( node_t *discard );
+
+
+/* External interface */
+void
+destroy_syntax_tree ( void )
+{
+    destroy_subtree ( root );
+}
+
+
+void
+simplify_syntax_tree ( void )
+{
+    simplify_tree ( &root, root );
+}
+
+
+extern bool new_print_style;
+void
+print_syntax_tree ( void )
+{
+    if (new_print_style)
+        tree_print ( root, 0 );
+    // Old tree printing
+    else
+        node_print ( root, 0 );
+}
+
+
+void
+node_init (node_t *nd, node_index_t type, void *data, uint64_t n_children, ...)
+{
+    va_list child_list;
+    *nd = (node_t) {
+        .type = type,
+        .data = data,
+        .entry = NULL,
+        .n_children = n_children,
+        .children = (node_t **) malloc ( n_children * sizeof(node_t *) )
+    };
+    va_start ( child_list, n_children );
+    for ( uint64_t i=0; i<n_children; i++ )
+        nd->children[i] = va_arg ( child_list, node_t * );
+    va_end ( child_list );
+}
+
+
+static void
+tree_print(node_t* root, stem head) 
+{
+    static const char *sdown = " │", *slast = " └", *snone = "  ";
+    struct stem_t col = {0, 0}, *tail;
+
+    // Print stems of branches coming further down
+    for (tail = head; tail; tail = tail->next) {
+        if (!tail->next) {
+            if (!strcmp(sdown, tail->str))
+                printf(" ├");
+            else 
+                printf("%s", tail->str);
+            break;
+        }
+        printf("%s", tail->str);
+    }
+    
+    if (root == NULL) {
+        // Secure against null pointers sent as root
+        printf("─(nil)\n");
+        return;
+    }
+    printf("─%s", node_string[root->type]);
+    if ( root->type == IDENTIFIER_DATA ||
+         root->type == STRING_DATA ||
+         root->type == EXPRESSION ) 
+        printf("(%s)", (char *) root->data);
+    else if (root->type == NUMBER_DATA)
+        printf("(%ld)", *((int64_t *)root->data));
+    putchar('\n');
+ 
+    if (!root->n_children) return;
+ 
+    if (tail && tail->str == slast)
+        tail->str = snone;
+ 
+    if (!tail)  tail = head = &col;
+    else        tail->next = &col;
+
+    for ( int64_t i=0; i < root->n_children; i++ ) {
+        col.str = root->n_children - i - 1 ? sdown : slast;
+        tree_print(root->children[i], head);
+    }
+    tail->next = 0;
+}
+
+/* Internal choices */
+static void
+node_print ( node_t *root, int nesting )
+{
+    if ( root != NULL )
+    {
+        printf ( "%*c%s", nesting, ' ', node_string[root->type] );
+        if ( root->type == IDENTIFIER_DATA ||
+             root->type == STRING_DATA ||
+             root->type == EXPRESSION ) 
+            printf ( "(%s)", (char *) root->data );
+        else if ( root->type == NUMBER_DATA )
+            printf ( "(%ld)", *((int64_t *)root->data) );
+        putchar ( '\n' );
+        for ( int64_t i=0; i<root->n_children; i++ )
+            node_print ( root->children[i], nesting+1 );
+    }
+    else
+        printf ( "%*c%p\n", nesting, ' ', root );
+}
+
+
+static void
+node_finalize ( node_t *discard )
+{
+    if ( discard != NULL )
+    {
+        free ( discard->data );
+        free ( discard->children );
+        free ( discard );
+    }
+}
+
+
+static void
+destroy_subtree ( node_t *discard )
+{
+    if ( discard != NULL )
+    {
+        for ( uint64_t i=0; i<discard->n_children; i++ )
+            destroy_subtree ( discard->children[i] );
+        node_finalize ( discard );
+    }
+}
+
+
+static void
+simplify_tree ( node_t **simplified, node_t *root )
+{
+    if ( root == NULL )
+        return;
+
+    /* Simplify subtrees before examining this node */
+    for ( uint64_t i=0; i<root->n_children; i++ )
+        simplify_tree ( &root->children[i], root->children[i] );
+
+    node_t *discard, *result = root;
+    switch ( root->type )
+    {
+        /* Structures of purely syntactic function */
+        case PARAMETER_LIST: case ARGUMENT_LIST:
+        case STATEMENT: case PRINT_ITEM: case GLOBAL:
+            result = root->children[0];
+            node_finalize ( root );
+            break;
+        case PRINT_STATEMENT:
+            result = root->children[0];
+            result->type = PRINT_STATEMENT;
+            node_finalize(root);
+        /* Flatten lists:
+         * Take left child, append right child, substitute left for root.
+         */
+        case STATEMENT_LIST: case DECLARATION_LIST: case GLOBAL_LIST:
+        case PRINT_LIST: case EXPRESSION_LIST: case VARIABLE_LIST:
+            if ( root->n_children >= 2 )
+            {
+                result = root->children[0];
+                result->n_children += 1;
+                result->children = realloc (
+                    result->children, result->n_children * sizeof(node_t *)
+                );
+                result->children[result->n_children-1] = root->children[1];
+                node_finalize ( root );
+            }
+            break;
+        case EXPRESSION:
+            switch ( root->n_children )
+            {
+                case 1:
+                    if ( root->children[0]->type == NUMBER_DATA )
+                    {
+                        result = root->children[0];
+                        if ( root->data != NULL )
+                            *((int64_t *)result->data) *= -1;
+                        node_finalize (root);
+                    }
+                    else if ( root->data == NULL )
+                    {
+                        result = root->children[0];
+                        node_finalize (root);
+                    }
+                    break;
+                case 2:
+                    if ( root->children[0]->type == NUMBER_DATA &&
+                         root->children[1]->type == NUMBER_DATA
+                    ) {
+                        result = root->children[0];
+                        int64_t
+                            *x = result->data,
+                            *y = root->children[1]->data;
+                        switch ( *((char *)root->data) )
+                        {
+                            case '+': *x += *y; break;
+                            case '-': *x -= *y; break;
+                            case '*': *x *= *y; break;
+                            case '/': *x /= *y; break;
+                        }
+                        node_finalize ( root->children[1] );
+                        node_finalize ( root );
+                    }
+                    break;
+            }
+    }
+    *simplified = result;
+}
diff --git a/exercises/04/vslc/src/vslc.c b/exercises/04/vslc/src/vslc.c
new file mode 100644
index 0000000..58e2f14
--- /dev/null
+++ b/exercises/04/vslc/src/vslc.c
@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <vslc.h>
+
+
+/* Global state */
+
+node_t *root;               // Syntax tree
+tlhash_t *global_names;     // Symbol table
+char **string_list;         // List of strings in the source
+size_t n_string_list = 8;   // Initial string list capacity (grow on demand)
+size_t stringc = 0;         // Initial string count
+
+/* Command line option parsing for the main function */
+static void options ( int argc, char **argv );
+bool
+    print_full_tree = false,
+    print_simplified_tree = false,
+    print_symbol_table_contents = false,
+    new_print_style = true;
+
+
+/* Entry point */
+int
+main ( int argc, char **argv )
+{
+    options ( argc, argv );
+
+    yyparse();  // Generated from grammar/bison, constructs syntax tree
+
+    if ( print_full_tree )
+        print_syntax_tree ();
+    simplify_syntax_tree ();    // In tree.c
+    if ( print_simplified_tree )
+        print_syntax_tree ();
+
+    create_symbol_table ();   // In ir.c
+    if ( print_symbol_table_contents )
+        print_symbol_table();
+
+    destroy_syntax_tree ();     // In tree.c
+    destroy_symbol_table ();    // In ir.c
+}
+
+
+static const char *usage =
+"Command line options\n"
+"\t-h\tOutput this text and halt\n"
+"\t-t\tOutput the full syntax tree\n"
+"\t-T\tOutput the simplified syntax tree\n"
+"\t-s\tOutput the symbol table contents\n"
+"\t-u\tDo not use print style more like the tree command\n";
+
+
+static void
+options ( int argc, char **argv )
+{
+    int o;
+    while ( (o=getopt(argc,argv,"htTsu")) != -1 )
+    {
+        switch ( o )
+        {
+            case 'h':
+                printf ( "%s:\n%s", argv[0], usage );
+                exit ( EXIT_FAILURE );
+                break;
+            case 't':   print_full_tree = true;             break;
+            case 'T':   print_simplified_tree = true;       break;
+            case 's':   print_symbol_table_contents = true; break;
+            case 'u':   new_print_style = false;            break;
+        }
+    }
+}
+
diff --git a/exercises/04/vslc/vsl_programs/Makefile b/exercises/04/vslc/vsl_programs/Makefile
new file mode 100644
index 0000000..d526e29
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/Makefile
@@ -0,0 +1,16 @@
+VSLC := ../src/vslc
+
+PS2_EXAMPLES := $(patsubst ps2-parser/%.vsl, ps2-parser/%.ast, $(wildcard ps2-parser/*.vsl))
+PS3_EXAMPLES := $(patsubst ps3-simplify/%.vsl, ps3-simplify/%.ast, $(wildcard ps3-simplify/*.vsl))
+PS4_EXAMPLES := $(patsubst ps4-symtab/%.vsl, ps4-symtab/%.ast, $(wildcard ps4-symtab/*.vsl))
+
+all: $(PS2_EXAMPLES) $(PS3_EXAMPLES) $(PS4_EXAMPLES)
+ps2: $(PS2_EXAMPLES)
+ps3: $(PS3_EXAMPLES)
+ps4: $(PS4_EXAMPLES)
+
+%.ast: %.vsl
+	$(VSLC) -t < $^ > $@
+
+clean:
+	-rm -r */*.ast
diff --git a/exercises/04/vslc/vsl_programs/ps2-parser/assignments.vsl b/exercises/04/vslc/vsl_programs/ps2-parser/assignments.vsl
new file mode 100644
index 0000000..b2f9227
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps2-parser/assignments.vsl
@@ -0,0 +1,14 @@
+// checking that comments are ignored
+
+// This program checks the assignment operators
+
+func main()
+begin
+    var a
+    a := 3
+    a += 1
+    a /= 2
+    a *= 32
+    a -= 2
+    print a
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps2-parser/function_call.vsl b/exercises/04/vslc/vsl_programs/ps2-parser/function_call.vsl
new file mode 100644
index 0000000..d5c75a5
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps2-parser/function_call.vsl
@@ -0,0 +1,8 @@
+func add(a, b) begin
+    return a + b
+end
+
+func main() 
+begin
+    print add(40, 2)
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps2-parser/helloworld.vsl b/exercises/04/vslc/vsl_programs/ps2-parser/helloworld.vsl
new file mode 100644
index 0000000..49219f8
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps2-parser/helloworld.vsl
@@ -0,0 +1,3 @@
+func main() begin
+    print "Hello, World!"
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps2-parser/if_else.ast b/exercises/04/vslc/vsl_programs/ps2-parser/if_else.ast
new file mode 100644
index 0000000..e69de29
diff --git a/exercises/04/vslc/vsl_programs/ps2-parser/if_else.vsl b/exercises/04/vslc/vsl_programs/ps2-parser/if_else.vsl
new file mode 100644
index 0000000..7d4fbe3
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps2-parser/if_else.vsl
@@ -0,0 +1,25 @@
+func main()
+begin
+    var a, b, c, d
+    c := 1
+    a := 3
+    b := a + c // 4
+    d := a * 100 + 50
+    print "a", a
+    print "b", b
+    print "c", c
+    print "d", d
+    if a = 14 then
+        print 1, "N", d / 5 + a, "RPR", a, "TERS "
+    else
+        print "COMP", c, "L", "ERS "
+    
+    print b, "R", a, " "
+
+    if a < b then
+        if d > 42 then
+            print b, "W", d, "ME"
+        else
+            print "L", b, "M", c
+    // A dangling else, what could go wrong?
+end
diff --git a/exercises/04/vslc/vsl_programs/ps2-parser/variables.vsl b/exercises/04/vslc/vsl_programs/ps2-parser/variables.vsl
new file mode 100644
index 0000000..abd12ec
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps2-parser/variables.vsl
@@ -0,0 +1,19 @@
+
+var global_var
+
+func my_func(param)
+begin
+    var local_var, local_var2
+    local_var := 1
+end
+
+var glob1, glob2
+
+func main()
+begin
+    var main_local_var
+    begin
+        var main_local_nested_var
+        main_local_nested_var := main_local_var
+    end
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps2-parser/while.vsl b/exercises/04/vslc/vsl_programs/ps2-parser/while.vsl
new file mode 100644
index 0000000..8d6b024
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps2-parser/while.vsl
@@ -0,0 +1,10 @@
+// check parsing of do-while loop
+
+func main()
+begin   
+    var i
+    i := 2
+    while i < 9000 do
+        i := i * i
+    print i
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps3-simplify/constants.vsl b/exercises/04/vslc/vsl_programs/ps3-simplify/constants.vsl
new file mode 100644
index 0000000..04fbf4e
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps3-simplify/constants.vsl
@@ -0,0 +1,9 @@
+
+func main() begin
+    var a
+    a := 1 + 2 + 4 + 5 + 6 + 7 + 8 + 9
+    b := (10 + 10 * 4) * (2 + 2 * (1 + 1)) / 10 + 2 * 5 + 6 / 3
+
+    if a = b then
+        print "The answer is", b
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps3-simplify/lists.vsl b/exercises/04/vslc/vsl_programs/ps3-simplify/lists.vsl
new file mode 100644
index 0000000..6d9f078
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps3-simplify/lists.vsl
@@ -0,0 +1,16 @@
+
+func my_fun(a, b, c, d, e, f, g, h) begin
+    var i, j, k, l, m
+
+    i := a + b + d
+
+    if i = f then begin
+        print "hmmm"
+    end
+end
+
+func main() begin
+    var n, o, p, q, r, s, t, u, v, w
+    n := 5
+    n += my_func(1, 2, 3, 5, 8, 13, 21, 34)
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps4-symtab/globals.vsl b/exercises/04/vslc/vsl_programs/ps4-symtab/globals.vsl
new file mode 100644
index 0000000..b6f6be5
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps4-symtab/globals.vsl
@@ -0,0 +1,11 @@
+var global_var0, global_var1
+
+func my_func(param0, param1) begin
+    var a
+    return 0
+end
+
+func main() begin
+    var a
+    print "a string"
+end
\ No newline at end of file
diff --git a/exercises/04/vslc/vsl_programs/ps4-symtab/shadow.vsl b/exercises/04/vslc/vsl_programs/ps4-symtab/shadow.vsl
new file mode 100644
index 0000000..324403b
--- /dev/null
+++ b/exercises/04/vslc/vsl_programs/ps4-symtab/shadow.vsl
@@ -0,0 +1,17 @@
+
+func main() begin
+    var a, b
+    a := 1
+    begin
+        var a
+        a := 2
+        b := 40
+        begin
+            var a
+            a := b + 2
+            print a, b
+        end
+        print a
+    end
+    print b
+end
\ No newline at end of file