diff --git a/boot/stage14.elna b/boot/stage14.elna
index ecb9347..9a6e18b 100644
--- a/boot/stage14.elna
+++ b/boot/stage14.elna
@@ -1598,8 +1598,8 @@ begin
 	_lexer_read_token(@token_kind);
 
 	if token_kind <> _lexer_token_kind_assignment() then
-		(* Else we assume this is a zeroed 81920 bytes big array. *)
-		_write_z(" .zero 81920\0")
+		(* Else we assume this is a zeroed 102400 bytes big array. *)
+		_write_z(" .zero 102400\0")
 	else
 		(* Skip the assignment sign with surrounding whitespaces. *)
 		_lexer_skip_token();
@@ -3038,7 +3038,7 @@ begin
 
 	.start_read;
 	(* Second argument is buffer size. Modifying update the source_code definition. *)
-	last_read := _read_file(offset, 81920);
+	last_read := _read_file(offset, 102400);
 	if last_read > 0 then
 		offset := offset + last_read;
 		goto .start_read
diff --git a/boot/stage15.elna b/boot/stage15.elna
index 6200fbd..3d05d1b 100644
--- a/boot/stage15.elna
+++ b/boot/stage15.elna
@@ -128,10 +128,14 @@ type
 		_goto,
 		eof
 	);
-	NodeKind := (
+	NodeKind = (
 		integer_literal,
 		string_literal,
-		character_literal
+		character_literal,
+		variable_expression,
+		field_access_expression,
+		dereference_expression,
+		unary_expression
 	);
 
 const
@@ -195,6 +199,7 @@ var
 proc _string_length(string: Word);
 var
 	counter: Word;
+	current_byte: Word;
 begin
 	(* Reset the counter. *)
 	counter := 0;
@@ -202,7 +207,8 @@ begin
 	.string_length_loop;
 	string := string + 1;
 
-	if _load_byte(string) <> '"' then
+	current_byte := _load_byte(string);
+	if current_byte <> '"' then
 		counter := counter + 1;
 		goto string_length_loop
 	end;
@@ -228,8 +234,8 @@ begin
 	result := compiler_strings_length;
 
 	.add_string_loop;
-	if _load_byte(contents) <> '"' then
-		current_byte := _load_byte(contents);
+	current_byte := _load_byte(contents);
+	if current_byte <> '"' then
 		_store_byte(current_byte, compiler_strings_position);
 		compiler_strings_position := compiler_strings_position + 1;
 		contents := contents + 1;
@@ -547,7 +553,8 @@ begin
 	memory_free_pointer := memory_free_pointer + 12;
 
 	integer_token := _lexer_global_get_start();
-	integer_length := _lexer_global_get_end() - integer_token;
+	integer_length := _lexer_global_get_end();
+	integer_length := integer_length - integer_token;
 	_lexer_skip_token();
 
 	_node_set_kind(result, NodeKind.integer_literal);
@@ -600,7 +607,8 @@ begin
 	memory_free_pointer := memory_free_pointer + 12;
 
 	character := _lexer_global_get_start();
-	character_length := _lexer_global_get_end() - character;
+	character_length := _lexer_global_get_end();
+	character_length := character_length - character;
 	_lexer_skip_token();
 
 	_node_set_kind(result, NodeKind.character_literal);
@@ -623,54 +631,82 @@ begin
 	_write_c('\n');
 end;
 
-proc _compile_variable_expression();
+proc _variable_expression_size();
+	return 12
+end;
+
+proc _variable_expression_get_name(this: Word);
+begin
+	this := this + 4;
+	return this^
+end;
+
+proc _variable_expression_set_name(this: Word, value: Word);
+begin
+	this := this + 4;
+	this^ := value
+end;
+
+proc _variable_expression_get_length(this: Word);
+begin
+	this := this + 8;
+	return this^
+end;
+
+proc _variable_expression_set_length(this: Word, value: Word);
+begin
+	this := this + 8;
+	this^ := value
+end;
+
+proc _allocate(size: Word);
+var
+	result: Word;
+begin
+	result := memory_free_pointer;
+	memory_free_pointer := memory_free_pointer + size;
+	return result
+end;
+
+proc _parse_variable_expression();
 var
 	name: Word;
-	lookup_result: Word;
 	name_token: Word;
+	result: Word;
+	memory_size: Word;
 begin
 	name := _lexer_global_get_start();
-	name_token := _lexer_global_get_end() - name;
-	lookup_result := _symbol_table_lookup(@symbol_table_global, name, name_token);
+	name_token := _lexer_global_get_end();
+	name_token := name_token - name;
+	_lexer_skip_token();
 
+	memory_size := _variable_expression_size();
+	result := _allocate(memory_size);
+
+	_node_set_kind(result, NodeKind.variable_expression);
+	_variable_expression_set_name(result, name);
+	_variable_expression_set_length(result, name_token);
+
+	return result
+end;
+
+proc _compile_variable_expression(variable_expression: Word);
+var
+	name: Word;
+	name_token: Word;
+	lookup_result: Word;
+begin
+	name := _variable_expression_get_name(variable_expression);
+	name_token := _variable_expression_get_length(variable_expression);
+
+	lookup_result := _symbol_table_lookup(@symbol_table_local, name, name_token);
 	if lookup_result <> 0 then
-		_compile_enumeration_value(lookup_result)
+		_compile_local_designator(lookup_result)
 	else
-		_compile_designator();
-		_write_z("\tlw t0, (t0)\n\0")
+		_compile_global_designator(variable_expression)
 	end
 end;
 
-(**
- * Compiled take address expression, starting with an "@" sign.
- *)
-proc _compile_address_expression();
-begin
-	_lexer_skip_token();
-	_compile_designator()
-end;
-
-(**
- * Compile unary negation, "-" sign.
- *)
-proc _compile_negate_expression();
-begin
-	_lexer_skip_token();
-	_compile_term();
-	_write_z("\tneg t0, t0\n\0")
-end;
-
-(* Compile unary negation, "~" sign. *)
-proc _compile_not_expression();
-var
-	token_kind: Word;
-begin
-	_lexer_read_token(@token_kind);
-	_lexer_skip_token();
-	_compile_term();
-	_write_z("\tnot t0, t0\n\0")
-end; 
-
 proc _string_literal_node_size();
 	return 12
 end;
@@ -698,14 +734,16 @@ var
 	length: Word;
 	token_start: Word;
 	result: Word;
+	memory_size: Word;
 begin
-	result := memory_free_pointer;
-	memory_free_pointer := memory_free_pointer + _string_literal_node_size();
+	memory_size := _string_literal_node_size();
+	result := _allocate(memory_size);
 
 	token_start := _lexer_global_get_start();
 	length := _string_length(token_start);
 	_lexer_skip_token();
 
+	_node_set_kind(result, NodeKind.string_literal);
 	_string_literal_node_set_value(result, token_start);
 	_string_literal_node_set_length(result, length);
 
@@ -731,48 +769,206 @@ begin
 	_write_z("\tadd t0, t0, t1\n\0")
 end;
 
-proc _compile_term();
+proc _parse_simple_expression();
 var
 	current_character: Word;
-	token_kind: Word;
 	parser_node: Word;
+	token_kind: Word;
 begin
+	parser_node := 0;
 	_lexer_read_token(@token_kind);
 
 	if token_kind = LexerTokenKind.character then
-		parser_node := _parse_character_literal();
-		_compile_character_literal(parser_node)
-	elsif token_kind = LexerTokenKind.string then
-		parser_node := _parse_string_literal();
-		_compile_string_literal(parser_node)
+		parser_node := _parse_character_literal()
 	elsif token_kind = LexerTokenKind.integer then
-		parser_node := _parse_integer_literal();
-		_compile_integer_literal(parser_node)
-	elsif token_kind = LexerTokenKind.at then
-		_compile_address_expression()
-	elsif token_kind = LexerTokenKind.minus then
-		_compile_negate_expression()
-	elsif token_kind = LexerTokenKind.not then
-		_compile_not_expression()
+		parser_node := _parse_integer_literal()
+	elsif token_kind = LexerTokenKind.string then
+		parser_node := _parse_string_literal()
 	elsif token_kind = LexerTokenKind.identifier then
 		current_character := _lexer_global_get_start();
 		current_character := _load_byte(current_character);
 
 		(* This is a call if the statement starts with an underscore. *)
-		if current_character = '_' then
-			_compile_call();
-			_write_z("\tmv t0, a0\n\0")
-		else
-			_compile_variable_expression()
+		if current_character <> '_' then
+			parser_node := _parse_variable_expression()
 		end
+	end;
+	return parser_node
+end;
+
+proc _dereference_expression_size();
+	return 8
+end;
+
+proc _dereference_expression_get_pointer(this: Word);
+begin
+	this := this + 4;
+	return this^
+end;
+
+proc _dereference_expression_set_pointer(this: Word, value: Word);
+begin
+	this := this + 4;
+	this^ := value
+end;
+
+proc _parse_dereference_expression(simple_expression: Word);
+var
+	result: Word;
+	memory_size: Word;
+begin
+	memory_size := _dereference_expression_size();
+	result := _allocate(memory_size);
+
+	_node_set_kind(result, NodeKind.dereference_expression);
+	_dereference_expression_set_pointer(result, simple_expression);
+	_lexer_skip_token();
+
+	return result
+end;
+
+proc _parse_designator();
+var
+	simple_expression: Word;
+	token_kind: Word;
+begin
+	simple_expression := _parse_simple_expression();
+
+	_lexer_read_token(@token_kind);
+
+	if token_kind = LexerTokenKind.hat then
+		simple_expression := _parse_dereference_expression(simple_expression)
+	elsif token_kind = LexerTokenKind.dot then
+		simple_expression := _parse_field_access_expression(simple_expression)
+	end;
+	return simple_expression
+end;
+
+proc _compile_simple_expression(parser_node: Word);
+var
+	is_address: Word;
+	node_kind: Word;
+begin
+	is_address := 0;
+	node_kind := _node_get_kind(parser_node);
+
+	if node_kind = NodeKind.character_literal then
+		_compile_character_literal(parser_node)
+	elsif node_kind = NodeKind.string_literal then
+		_compile_string_literal(parser_node)
+	elsif node_kind = NodeKind.integer_literal then
+		_compile_integer_literal(parser_node)
+	else
+		_compile_variable_expression(parser_node);
+		is_address := 1
+	end;
+	return is_address
+end;
+
+proc _unary_expression_size();
+	return 12
+end;
+
+proc _unary_expression_get_operand(this: Word);
+begin
+	this := this + 4;
+	return this^
+end;
+
+proc _unary_expression_set_operand(this: Word, value: Word);
+begin
+	this := this + 4;
+	this^ := value
+end;
+
+proc _unary_expression_get_operator(this: Word);
+begin
+	this := this + 8;
+	return this^
+end;
+
+proc _unary_expression_set_operator(this: Word, value: Word);
+begin
+	this := this + 8;
+	this^ := value
+end;
+
+proc _parse_unary_expression();
+var
+	token_kind: Word;
+	result: Word;
+	memory_size: Word;
+	operand: Word;
+	operator: Word;
+begin
+	_lexer_read_token(@token_kind);
+	operator := 0;
+
+	if token_kind = LexerTokenKind.at then
+		operator := '@';
+	elsif token_kind = LexerTokenKind.minus then
+		operator := '-';
+	elsif token_kind = LexerTokenKind.not then
+		operator := '~';
+	end;
+	if operator <> 0 then
+		_lexer_skip_token();
+	end;
+	result := _parse_designator();
+
+	if operator <> 0 then
+		operand := result;
+		memory_size := _unary_expression_size();
+		result := _allocate(memory_size);
+
+		_node_set_kind(result, NodeKind.unary_expression);
+		_unary_expression_set_operand(result, operand);
+		_unary_expression_set_operator(result, operator)
+	end;
+
+	return result
+end;
+
+proc _compile_unary_expression(parser_node: Word);
+var
+	current_character: Word;
+	token_kind: Word;
+	expression_kind: Word;
+	operator: Word;
+	operand: Word;
+begin
+	operator := 0;
+	operand := 0;
+
+	expression_kind := _node_get_kind(parser_node);
+
+	if expression_kind = NodeKind.unary_expression then
+		operator := _unary_expression_get_operator(parser_node);
+		operand := _unary_expression_get_operand(parser_node)
+	else
+		operand := parser_node
+	end;
+
+	if operator = '@' then
+		_compile_designator(operand)
+	elsif _compile_designator(operand) then
+		_write_z("\tlw t0, (t0) # Designator is an address.\n\0")
+	end;
+	if operator = '-' then
+		_write_z("\tneg t0, t0\n\0")
+	elsif operator = '~' then
+		_write_z("\tnot t0, t0\n\0")
 	end
 end;
 
 proc _compile_binary_rhs();
+var
+	parser_node: Word;
 begin
 	(* Save the value of the left expression on the stack. *)
 	_write_z("\tsw t0, 64(sp)\n\0");
-	_compile_term();
+	parser_node := _parse_unary_expression();
+	_compile_unary_expression(parser_node);
 
 	(* Load the left expression from the stack; *)
 	_write_z("\tlw t1, 64(sp)\n\0")
@@ -781,8 +977,22 @@ end;
 proc _compile_expression();
 var
 	token_kind: Word;
+	current_byte: Word;
+	parser_node: Word;
 begin
-	_compile_term();
+	_lexer_read_token(@token_kind);
+	if token_kind = LexerTokenKind.identifier then
+		current_byte := _lexer_global_get_start();
+		current_byte := _load_byte(current_byte);
+
+		if current_byte = '_' then
+			_compile_call();
+			_write_z("\tmv t0, a0\n\0");
+			goto compile_expression_end
+		end
+	end;
+	parser_node := _parse_unary_expression();
+	_compile_unary_expression(parser_node);
 
 	_lexer_read_token(@token_kind);
 
@@ -885,7 +1095,8 @@ var
 begin
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - name;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - name;
 	argument_count := 0;
 
 	(* Skip the identifier and left paren. *)
@@ -964,7 +1175,8 @@ begin
 		_lexer_read_token(@token_kind)
 	end;
 	next_token := _lexer_global_get_start();
-	next_length := _lexer_global_get_end() - next_token;
+	next_length := _lexer_global_get_end();
+	next_length := next_length - next_token;
 
 	_write_z("\tj .\0");
 
@@ -979,28 +1191,64 @@ begin
 	_write_z("\taddi t0, sp, \0");
 	variable_offset := _parameter_info_get_offset(symbol);
 	_write_i(variable_offset);
-	_write_c('\n');
-	_lexer_skip_token()
+	_write_c('\n')
 end;
 
-proc _compile_global_designator();
+proc _compile_global_designator(variable_expression: Word);
 var
 	name: Word;
-	token_kind: Word;
 	token_length: Word;
 begin
 	_write_z("\tla t0, \0");
 
-	_lexer_read_token(@token_kind);
-	name := _lexer_global_get_start();
-	token_length := _lexer_global_get_end() - name;
-	_write_s(name, token_length);
-	_lexer_skip_token();
+	name := _variable_expression_get_name(variable_expression);
+	token_length := _variable_expression_get_length(variable_expression);
 
+	_write_s(name, token_length);
 	_write_c('\n')
 end;
 
-proc _compile_enumeration_value(symbol: Word);
+proc _field_access_expression_size();
+	return 16
+end;
+
+proc _field_access_expression_get_aggregate(this: Word);
+begin
+	this := this + 4;
+	return this^
+end;
+
+proc _field_access_expression_set_aggregate(this: Word, value: Word);
+begin
+	this := this + 4;
+	this^ := value
+end;
+
+proc _field_access_expression_get_field(this: Word);
+begin
+	this := this + 8;
+	return this^
+end;
+
+proc _field_access_expression_set_field(this: Word, value: Word);
+begin
+	this := this + 8;
+	this^ := value
+end;
+
+proc _field_access_expression_get_length(this: Word);
+begin
+	this := this + 12;
+	return this^
+end;
+
+proc _field_access_expression_set_length(this: Word, value: Word);
+begin
+	this := this + 12;
+	this^ := value
+end;
+
+proc _compile_enumeration_value(field_access_expression: Word);
 var
 	enumeration_type: Word;
 	members: Word;
@@ -1011,20 +1259,22 @@ var
 	member_name: Word;
 	member_length: Word;
 	counter: Word;
+	symbol: Word;
 begin
+	symbol := _field_access_expression_get_aggregate(field_access_expression);
+	value_name := _variable_expression_get_name(symbol);
+	name_length := _variable_expression_get_length(symbol);
+
+	symbol := _symbol_table_lookup(@symbol_table_global, value_name, name_length);
+
 	enumeration_type := _type_info_get_type(symbol);
 	members := _enumeration_type_get_members(enumeration_type);
 	members_length := _enumeration_type_get_length(enumeration_type);
 
-	(* Skip enumeration type name and dot. Read the enumeration value. *)
-	_lexer_skip_token();
-	_lexer_read_token(@token_type);
-	_lexer_skip_token();
 	_lexer_read_token(@token_type);
 
-	value_name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - value_name;
-	_lexer_skip_token();
+	value_name := _field_access_expression_get_field(field_access_expression);
+	name_length := _field_access_expression_get_length(field_access_expression);
 	counter := 1;
 
 	.compile_enumeration_value_members;
@@ -1032,7 +1282,8 @@ begin
 		member_name := members^;
 		member_length := _load_word(members + 4);
 
-		if _lexer_compare_keyword(value_name, name_length, member_name, member_length) = 0 then
+		if _lexer_compare_keyword(value_name, name_length, member_name, member_length) then
+		else
 			members_length := members_length - 1;
 			members := members + 8;
 			counter := counter + 1;
@@ -1044,35 +1295,64 @@ begin
 	end
 end;
 
-proc _compile_designator();
+proc _parse_field_access_expression(aggregate: Word);
+var
+	token_kind: Word;
+	name: Word;
+	name_token: Word;
+	result: Word;
+	memory_size: Word;
+begin
+	(* Skip dot. Read the enumeration value. *)
+	_lexer_skip_token();
+	_lexer_read_token(@token_kind);
+
+	name := _lexer_global_get_start();
+	name_token := _lexer_global_get_end();
+	name_token := name_token - name;
+	_lexer_skip_token();
+	memory_size := _field_access_expression_size();
+	result := _allocate(memory_size);
+
+	_node_set_kind(result, NodeKind.field_access_expression);
+	_field_access_expression_set_aggregate(result, aggregate);
+	_field_access_expression_set_field(result, name);
+	_field_access_expression_set_length(result, name_token);
+
+	return result
+end;
+
+proc _compile_designator(parser_node: Word);
 var
 	name_token: Word;
 	lookup_result: Word;
 	token_kind: Word;
-	name: Word;
+	parser_node: Word;
+	is_address: Word;
+	node_kind: Word;
 begin
-	_lexer_read_token(@token_kind);
-	name := _lexer_global_get_start();
-	name_token := _lexer_global_get_end() - name;
-	lookup_result := _symbol_table_lookup(@symbol_table_local, name, name_token);
+	is_address := 1;
+	node_kind := _node_get_kind(parser_node);
 
-	if lookup_result <> 0 then
-		_compile_local_designator(lookup_result)
-	else
-		_compile_global_designator()
-	end;
-	_lexer_read_token(@token_kind);
-	if token_kind = LexerTokenKind.hat then
-		_lexer_skip_token();
+	if node_kind = NodeKind.dereference_expression then
+		parser_node := _dereference_expression_get_pointer(parser_node);
+		_compile_simple_expression(parser_node);
 		_write_z("\tlw t0, (t0)\n\0")
-	end
+	elsif node_kind = NodeKind.field_access_expression then
+		_compile_enumeration_value(parser_node);
+		is_address := 0
+	else
+		is_address := _compile_simple_expression(parser_node)
+	end;
+	return is_address
 end;
 
 proc _compile_assignment();
 var
 	token_kind: Word;
 begin
-	_compile_designator();
+	token_kind := _parse_designator();
+	_compile_designator(token_kind);
 
 	(* Save the assignee address on the stack. *)
 	_write_z("\tsw t0, 60(sp)\n\0");
@@ -1082,6 +1362,7 @@ begin
 	_lexer_skip_token();
 
 	(* Compile the assignment. *)
+	_lexer_read_token(@token_kind);
 	_compile_expression();
 
 	_write_z("\tlw t1, 60(sp)\n\tsw t0, (t1)\n\0")
@@ -1182,7 +1463,8 @@ begin
 	_lexer_skip_token();
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	label_token := _lexer_global_get_end() - name;
+	label_token := _lexer_global_get_end();
+	label_token := label_token - name;
 	_write_c('.');
 	_write_s(name, label_token);
 	_write_z(":\n\0");
@@ -1315,7 +1597,8 @@ begin
 	member_count := member_count + 1;
 
 	enumeration_name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - enumeration_name;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - enumeration_name;
 
 	_store_word(enumeration_name, memory_free_pointer);
 	memory_free_pointer := memory_free_pointer + 4;
@@ -1362,7 +1645,8 @@ begin
 	if token_kind = LexerTokenKind.identifier then
 		(* Named type. *)
 		type_name := _lexer_global_get_start();
-		name_length := _lexer_global_get_end() - type_name;
+		name_length := _lexer_global_get_end();
+		name_length := name_length - type_name;
 		result := _symbol_table_lookup(@symbol_table_global, type_name, name_length);
 		result := _type_info_get_type(result);
 
@@ -1473,7 +1757,8 @@ begin
 	(* Read the parameter name. *)
 	_lexer_read_token(@token_kind);
 	name_position := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - name_position;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - name_position;
 	_lexer_skip_token();
 
 	(* Skip colon and space in front of the type expression. *)
@@ -1535,7 +1820,8 @@ var
 begin
 	_lexer_read_token(@token_kind);
 	name_position := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - name_position;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - name_position;
 	_lexer_skip_token();
 
 	(* Read and skip variable name, colon and the space *)
@@ -1590,7 +1876,8 @@ begin
 
 	_lexer_read_token(@token_kind);
 	name_pointer := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - name_pointer;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - name_pointer;
 
 	(* Write .type _procedure_name, @function. *)
 	_write_z(".type \0");
@@ -1689,14 +1976,20 @@ begin
 		_lexer_skip_token();
 		_write_z("\n\t.word \0");
 		_lexer_read_token(@token_kind);
-		token_start := _lexer_global_get_start();
-		_write_s(token_start, _lexer_global_get_end() - token_start);
-		_lexer_skip_token();
 
+		token_start := _lexer_global_get_start();
+		length := _lexer_global_get_end();
+		length := length - token_start;
+		_write_s(token_start,  length);
+
+		_lexer_skip_token();
 		goto compile_global_initializer_end
 	elsif token_kind = LexerTokenKind.integer then
 		_write_z("\n\t.word \0");
-		_write_s(token_start, _lexer_global_get_end() - token_start);
+
+		length := _lexer_global_get_end();
+		length := length - token_start;
+		_write_s(token_start,  length);
 		_lexer_skip_token();
 
 		goto compile_global_initializer_end
@@ -1727,7 +2020,8 @@ var
 	token_kind: Word;
 begin
 	name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - name;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - name;
 
 	_write_z(".type \0");
 	_write_s(name, name_length);
@@ -1756,7 +2050,8 @@ var
 	type_info: Word;
 begin
 	type_name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - type_name;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - type_name;
 
 	_lexer_skip_token();
 	_lexer_read_token(@token_kind);
@@ -1829,7 +2124,8 @@ var
 begin
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() - name;
+	name_length := _lexer_global_get_end();
+	name_length := name_length - name;
 
 	_write_z(".type \0");
 	_write_s(name, name_length);
@@ -1847,8 +2143,8 @@ begin
 	_lexer_read_token(@token_kind);
 
 	if token_kind <> LexerTokenKind.assignment then
-		(* Else we assume this is a zeroed 81920 bytes big array. *)
-		_write_z(" .zero 81920\0")
+		(* Else we assume this is a zeroed 102400 bytes big array. *)
+		_write_z(" .zero 102400\0")
 	else
 		(* Skip the assignment sign with surrounding whitespaces. *)
 		_lexer_skip_token();
@@ -1993,7 +2289,7 @@ begin
 		goto symbol_table_lookup_repeat
 	end;
 	(* If names don't match, exit and return nil. *)
-	if _memcmp(symbol_name, current_name, name_length) <> 0 then
+	if _memcmp(symbol_name, current_name, name_length) then
 		goto symbol_table_lookup_repeat
 	end;
 	(* Otherwise, the symbol is found. *)
@@ -2248,7 +2544,8 @@ begin
 	column_position := character_class - 1;
 	column_position := column_position * 8;
 
-	target := _lexer_get_transition_table() + row_position;
+	target := _lexer_get_transition_table();
+	target := target + row_position;
 
 	return target + column_position
 end;
@@ -2439,7 +2736,11 @@ end;
  * and 22 columns (character classes), so 2992 = 8 * 17 * 22.
  *)
 proc _lexer_global_state();
-	return _lexer_get_transition_table() + 2992
+var
+	result: Word;
+begin
+	result := _lexer_get_transition_table();
+	return  result + 2992
 end;
 
 (**
@@ -2449,7 +2750,8 @@ proc _lexer_global_get_start();
 var
 	target: Word;
 begin
-	target := _lexer_global_state() + 4;
+	target := _lexer_global_state();
+	target := target + 4;
 	return target^
 end;
 
@@ -2460,8 +2762,9 @@ proc _lexer_global_set_start(new_start: Word);
 var
 	target: Word;
 begin
-	target := _lexer_global_state() + 4;
-	_store_word(new_start, target)
+	target := _lexer_global_state();
+	target := target + 4;
+	target^ := new_start
 end;
 
 (**
@@ -2471,7 +2774,8 @@ proc _lexer_global_get_end();
 var
 	target: Word;
 begin
-	target := _lexer_global_state() + 8;
+	target := _lexer_global_state();
+	target := target + 8;
 	return target^
 end;
 
@@ -2482,8 +2786,9 @@ proc _lexer_global_set_end(new_start: Word);
 var
 	target: Word;
 begin
-	target := _lexer_global_state() + 8;
-	_store_word(new_start, target)
+	target := _lexer_global_state();
+	target := target + 8;
+	target^ := new_start
 end;
 
 proc _lexer_transition_get_action(transition: Word);
@@ -2555,7 +2860,8 @@ begin
 	result := 0;
 
 	if lhs_length = rhs_length then
-		result := _memcmp(lhs_pointer, rhs_pointer, lhs_length) = 0
+		result := _memcmp(lhs_pointer, rhs_pointer, lhs_length);
+		result := result = 0
 	end;
 	return result
 end;
@@ -2568,35 +2874,35 @@ begin
 	result := LexerTokenKind.identifier;
 	token_length := position_end - position_start;
 
-	if _lexer_compare_keyword(position_start, token_length, "const", 5) = 1 then
+	if _lexer_compare_keyword(position_start, token_length, "const", 5) then
 		result := LexerTokenKind._const
-	elsif _lexer_compare_keyword(position_start, token_length, "var", 3) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "var", 3) then
 		result := LexerTokenKind._var
-	elsif _lexer_compare_keyword(position_start, token_length, "proc", 4) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "proc", 4) then
 		result := LexerTokenKind._proc
-	elsif _lexer_compare_keyword(position_start, token_length, "type", 4) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "type", 4) then
 		result := LexerTokenKind._type
-	elsif _lexer_compare_keyword(position_start, token_length, "begin", 5) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "begin", 5) then
 		result := LexerTokenKind._begin
-	elsif _lexer_compare_keyword(position_start, token_length, "end", 3) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "end", 3) then
 		result := LexerTokenKind._end
-	elsif _lexer_compare_keyword(position_start, token_length, "return", 6) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "return", 6) then
 		result := LexerTokenKind._return
-	elsif _lexer_compare_keyword(position_start, token_length, "goto", 4) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "goto", 4) then
 		result := LexerTokenKind._goto
-	elsif _lexer_compare_keyword(position_start, token_length, "if", 2) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "if", 2) then
 		result := LexerTokenKind._if
-	elsif _lexer_compare_keyword(position_start, token_length, "while", 5) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "while", 5) then
 		result := LexerTokenKind._while
-	elsif _lexer_compare_keyword(position_start, token_length, "then", 4) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "then", 4) then
 		result := LexerTokenKind._then
-	elsif _lexer_compare_keyword(position_start, token_length, "else", 4) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "else", 4) then
 		result := LexerTokenKind._else
-	elsif _lexer_compare_keyword(position_start, token_length, "elsif", 5) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "elsif", 5) then
 		result := LexerTokenKind._elsif
-	elsif _lexer_compare_keyword(position_start, token_length, "or", 2) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "or", 2) then
 		result := LexerTokenKind._or
-	elsif _lexer_compare_keyword(position_start, token_length, "xor", 2) = 1 then
+	elsif _lexer_compare_keyword(position_start, token_length, "xor", 2) then
 		result := LexerTokenKind._xor
 	end;
 	return result
@@ -2779,8 +3085,11 @@ begin
 end;
 
 proc _lexer_advance_token(kind: Word);
+var
+	result_state: Word;
 begin
-	if _lexer_execute_transition(kind) <> LexerState.finish then
+	result_state := _lexer_execute_transition(kind);
+	if result_state <> LexerState.finish then
 		_lexer_advance_token(kind)
 	end
 end;
@@ -2821,7 +3130,7 @@ begin
 
 	.start_read;
 	(* Second argument is buffer size. Modifying update the source_code definition. *)
-	last_read := _read_file(offset, 81920);
+	last_read := _read_file(offset, 102400);
 	if last_read > 0 then
 		offset := offset + last_read;
 		goto start_read