diff --git a/src/arch/z80/backend/_array.py b/src/arch/z80/backend/_array.py
index 1d2e60f62..22f88d461 100644
--- a/src/arch/z80/backend/_array.py
+++ b/src/arch/z80/backend/_array.py
@@ -313,8 +313,8 @@ def _astoref(ins: Quad) -> list[str]:
 
 def _astorestr(ins: Quad) -> list[str]:
     """Stores a string value into a memory address.
-    It copies content of 2nd operand (string), into 1st, reallocating
-    dynamic memory for the 1st str. These instruction DOES ALLOW
+    It copies the content of the 2nd operand (string), into 1st, reallocating
+    dynamic memory for the 1st str. These instructions DO ALLOW
     immediate strings for the 2nd parameter, starting with '#'.
     """
     output = _addr(ins[1])
diff --git a/src/arch/z80/backend/_parray.py b/src/arch/z80/backend/_parray.py
index 33b21e429..dd324a9e9 100644
--- a/src/arch/z80/backend/_parray.py
+++ b/src/arch/z80/backend/_parray.py
@@ -284,22 +284,25 @@ def _pastoref(ins: Quad) -> list[str]:
 
 def _pastorestr(ins: Quad) -> list[str]:
     """Stores a string value into a memory address.
-    It copies content of 2nd operand (string), into 1st, reallocating
-    dynamic memory for the 1st str. These instruction DOES ALLOW
+    It copies the content of the 2nd operand (string), into 1st, reallocating
+    dynamic memory for the 1st str. These instructions DO ALLOW
     immediate strings for the 2nd parameter, starting with '#'.
     """
     output = _paddr(ins[1])
-    temporal = False
     value = ins[2]
 
     indirect = value[0] == "*"
     if indirect:
         value = value[1:]
 
-    immediate = value[0]
+    immediate = value[0] == "#"
     if immediate:
         value = value[1:]
 
+    temporal = not immediate and value[0] != "$"
+    if temporal:
+        value = value[1:]
+
     if value[0] == "_":
         if indirect:
             if immediate:
@@ -313,8 +316,10 @@ def _pastorestr(ins: Quad) -> list[str]:
             else:
                 output.append("ld de, (%s)" % value)
     else:
-        output.append("pop de")
-        temporal = True
+        if immediate:
+            output.append("ld de, %s" % value)
+        else:
+            output.append("pop de")
 
         if indirect:
             output.append(runtime_call(RuntimeLabel.LOAD_DE_DE))
diff --git a/src/symbols/id_/ref/varref.py b/src/symbols/id_/ref/varref.py
index 344e63fb9..36538833d 100644
--- a/src/symbols/id_/ref/varref.py
+++ b/src/symbols/id_/ref/varref.py
@@ -39,7 +39,7 @@ def t(self) -> str:
         if self.parent.type_ is None or not self.parent.type_.is_dynamic:
             return self._t
 
-        return f"${self._t}"  # Local string variables (and parameters) use '$' (see backend)
+        return f"${self._t}"  # Local string variables (and ByVal parameters) use '$' (see backend)
 
     @property
     def size(self) -> int:
diff --git a/src/symbols/sentence.py b/src/symbols/sentence.py
index 51912b143..d2153e088 100644
--- a/src/symbols/sentence.py
+++ b/src/symbols/sentence.py
@@ -29,5 +29,5 @@ def args(self):
 
     @property
     def token(self):
-        """Sentence takes it's token from the keyword not from it's name"""
+        """Sentence takes its token from the keyword not from its name"""
         return self.keyword
diff --git a/src/zxbc/zxbparser.py b/src/zxbc/zxbparser.py
index 6449c8f68..41071ba0e 100755
--- a/src/zxbc/zxbparser.py
+++ b/src/zxbc/zxbparser.py
@@ -371,7 +371,7 @@ def make_call(id_: str, lineno: int, args: sym.ARGLIST):
     - a(4) can be a string slice if 'a' is a string variable: a$(4)
     - a(4) can be an access to an array if 'a' is an array
 
-    This function will inspect the id_. If it is undeclared then
+    This function will inspect the id_. If it is undeclared, then
     id_ will be taken as a forwarded function.
     """
     if args is None:
@@ -1198,7 +1198,8 @@ def p_arr_assignment(p):
 
     if entry.type_ == TYPE.string:
         variable = gl.SYMBOL_TABLE.access_array(id_, p.lineno(i))
-        if len(variable.ref.bounds) + 1 == len(arg_list):
+        # variable is an array. If it has 0 bounds means they are undefined (param byref)
+        if len(variable.ref.bounds) and len(variable.ref.bounds) + 1 == len(arg_list):
             ss = arg_list.children.pop().value
             p[0] = make_array_substr_assign(p.lineno(i), id_, arg_list, (ss, ss), expr)
             return
diff --git a/tests/functional/arch/zx48k/arr_elem_by_ref01.asm b/tests/functional/arch/zx48k/arr_elem_by_ref01.asm
new file mode 100644
index 000000000..c413a82be
--- /dev/null
+++ b/tests/functional/arch/zx48k/arr_elem_by_ref01.asm
@@ -0,0 +1,236 @@
+	org 32768
+.core.__START_PROGRAM:
+	di
+	push ix
+	push iy
+	exx
+	push hl
+	exx
+	ld (.core.__CALL_BACK__), sp
+	ei
+	jp .core.__MAIN_PROGRAM__
+.core.__CALL_BACK__:
+	DEFW 0
+.core.ZXBASIC_USER_DATA:
+	; Defines USER DATA Length in bytes
+.core.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_END - .core.ZXBASIC_USER_DATA
+	.core.__LABEL__.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_LEN
+	.core.__LABEL__.ZXBASIC_USER_DATA EQU .core.ZXBASIC_USER_DATA
+_a:
+	DEFW .LABEL.__LABEL0
+_a.__DATA__.__PTR__:
+	DEFW _a.__DATA__
+	DEFW 0
+	DEFW 0
+_a.__DATA__:
+	DEFB 01h
+	DEFB 02h
+	DEFB 03h
+.LABEL.__LABEL0:
+	DEFW 0000h
+	DEFB 01h
+.core.ZXBASIC_USER_DATA_END:
+.core.__MAIN_PROGRAM__:
+	ld hl, 1
+	push hl
+	ld hl, _a
+	call .core.__ARRAY
+	push hl
+	call _Incr
+	ld a, (_a.__DATA__ + 1)
+	ld (0), a
+	ld hl, 0
+	ld b, h
+	ld c, l
+.core.__END_PROGRAM:
+	di
+	ld hl, (.core.__CALL_BACK__)
+	ld sp, hl
+	exx
+	pop hl
+	exx
+	pop iy
+	pop ix
+	ei
+	ret
+_Incr:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld a, (hl)
+	inc a
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld (hl), a
+_Incr__leave:
+	ld sp, ix
+	pop ix
+	exx
+	pop hl
+	ex (sp), hl
+	exx
+	ret
+	;; --- end of user code ---
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	; -------------------------------------------------------------------
+	; Simple array Index routine
+	; Number of total indexes dimensions - 1 at beginning of memory
+	; HL = Start of array memory (First two bytes contains N-1 dimensions)
+	; Dimension values on the stack, (top of the stack, highest dimension)
+	; E.g. A(2, 4) -> PUSH <4>; PUSH <2>
+	; For any array of N dimension A(aN-1, ..., a1, a0)
+	; and dimensions D[bN-1, ..., b1, b0], the offset is calculated as
+	; O = [a0 + b0 * (a1 + b1 * (a2 + ... bN-2(aN-1)))]
+; What I will do here is to calculate the following sequence:
+	; ((aN-1 * bN-2) + aN-2) * bN-3 + ...
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	;; Performs a faster multiply for little 16bit numbs
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/mul16.asm"
+	    push namespace core
+__MUL16:	; Mutiplies HL with the last value stored into de stack
+	    ; Works for both signed and unsigned
+	    PROC
+	    LOCAL __MUL16LOOP
+	    LOCAL __MUL16NOADD
+	    ex de, hl
+	    pop hl		; Return address
+	    ex (sp), hl ; CALLEE caller convention
+__MUL16_FAST:
+	    ld b, 16
+	    ld a, h
+	    ld c, l
+	    ld hl, 0
+__MUL16LOOP:
+	    add hl, hl  ; hl << 1
+	    sla c
+	    rla         ; a,c << 1
+	    jp nc, __MUL16NOADD
+	    add hl, de
+__MUL16NOADD:
+	    djnz __MUL16LOOP
+	    ret	; Result in hl (16 lower bits)
+	    ENDP
+	    pop namespace
+#line 3 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	    push namespace core
+__FMUL16:
+	    xor a
+	    or h
+	    jp nz, __MUL16_FAST
+	    or l
+	    ret z
+	    cp 33
+	    jp nc, __MUL16_FAST
+	    ld b, l
+	    ld l, h  ; HL = 0
+1:
+	    add hl, de
+	    djnz 1b
+	    ret
+	    pop namespace
+#line 20 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+#line 24 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    push namespace core
+__ARRAY_PTR:   ;; computes an array offset from a pointer
+	    ld c, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, c    ;; HL <-- [HL]
+__ARRAY:
+	    PROC
+	    LOCAL LOOP
+	    LOCAL ARRAY_END
+	    LOCAL TMP_ARR_PTR            ; Ptr to Array DATA region. Stored temporarily
+	    LOCAL LBOUND_PTR, UBOUND_PTR ; LBound and UBound PTR indexes
+	    LOCAL RET_ADDR               ; Contains the return address popped from the stack
+	LBOUND_PTR EQU 23698           ; Uses MEMBOT as a temporary variable
+	UBOUND_PTR EQU LBOUND_PTR + 2  ; Next 2 bytes for UBOUND PTR
+	RET_ADDR EQU UBOUND_PTR + 2    ; Next 2 bytes for RET_ADDR
+	TMP_ARR_PTR EQU RET_ADDR + 2   ; Next 2 bytes for TMP_ARR_PTR
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    inc hl      ; DE <-- PTR to Dim sizes table
+	    ld (TMP_ARR_PTR), hl  ; HL = Array __DATA__.__PTR__
+	    inc hl
+	    inc hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)  ; BC <-- Array __LBOUND__ PTR
+	    ld (LBOUND_PTR), bc  ; Store it for later
+#line 66 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl   ; HL <-- PTR to Dim sizes table, DE <-- dummy
+	    ex (sp), hl	; Return address in HL, PTR Dim sizes table onto Stack
+	    ld (RET_ADDR), hl ; Stores it for later
+	    exx
+	    pop hl		; Will use H'L' as the pointer to Dim sizes table
+	    ld c, (hl)	; Loads Number of dimensions from (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl		; Ready
+	    exx
+	    ld hl, 0	; HL = Element Offset "accumulator"
+LOOP:
+	    ex de, hl   ; DE = Element Offset
+	    ld hl, (LBOUND_PTR)
+	    ld a, h
+	    or l
+	    ld b, h
+	    ld c, l
+	    jr z, 1f
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl
+	    ld (LBOUND_PTR), hl
+1:
+	    pop hl      ; Get next index (Ai) from the stack
+	    sbc hl, bc  ; Subtract LBOUND
+#line 116 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    add hl, de	; Adds current index
+	    exx			; Checks if B'C' = 0
+	    ld a, b		; Which means we must exit (last element is not multiplied by anything)
+	    or c
+	    jr z, ARRAY_END		; if B'Ci == 0 we are done
+	    dec bc				; Decrements loop counter
+	    ld e, (hl)			; Loads next dimension size into D'E'
+	    inc hl
+	    ld d, (hl)
+	    inc hl
+	    push de
+	    exx
+	    pop de				; DE = Max bound Number (i-th dimension)
+	    call __FMUL16        ; HL <= HL * DE mod 65536
+	    jp LOOP
+ARRAY_END:
+	    ld a, (hl)
+	    exx
+#line 146 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    LOCAL ARRAY_SIZE_LOOP
+	    ex de, hl
+	    ld hl, 0
+	    ld b, a
+ARRAY_SIZE_LOOP:
+	    add hl, de
+	    djnz ARRAY_SIZE_LOOP
+#line 156 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl
+	    ld hl, (TMP_ARR_PTR)
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a
+	    add hl, de  ; Adds element start
+	    ld de, (RET_ADDR)
+	    push de
+	    ret
+	    ENDP
+	    pop namespace
+#line 44 "arch/zx48k/arr_elem_by_ref01.bas"
+	END
diff --git a/tests/functional/arch/zx48k/arr_elem_by_ref01.bas b/tests/functional/arch/zx48k/arr_elem_by_ref01.bas
new file mode 100644
index 000000000..d4e8fc9af
--- /dev/null
+++ b/tests/functional/arch/zx48k/arr_elem_by_ref01.bas
@@ -0,0 +1,10 @@
+REM Test passing an array element by ref
+
+DIM a(2) As UByte => {1, 2, 3}
+
+SUB Incr(ByRef x As UByte)
+  LET x = x + 1
+END SUB
+
+Incr(a(1))
+POKE 0, a(1)
diff --git a/tests/functional/arch/zx48k/arr_elem_by_ref02.asm b/tests/functional/arch/zx48k/arr_elem_by_ref02.asm
new file mode 100644
index 000000000..a128f50be
--- /dev/null
+++ b/tests/functional/arch/zx48k/arr_elem_by_ref02.asm
@@ -0,0 +1,840 @@
+	org 32768
+.core.__START_PROGRAM:
+	di
+	push ix
+	push iy
+	exx
+	push hl
+	exx
+	ld (.core.__CALL_BACK__), sp
+	ei
+	call .core.__MEM_INIT
+	jp .core.__MAIN_PROGRAM__
+.core.__CALL_BACK__:
+	DEFW 0
+.core.ZXBASIC_USER_DATA:
+	; Defines HEAP SIZE
+.core.ZXBASIC_HEAP_SIZE EQU 4768
+.core.ZXBASIC_MEM_HEAP:
+	DEFS 4768
+	; Defines USER DATA Length in bytes
+.core.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_END - .core.ZXBASIC_USER_DATA
+	.core.__LABEL__.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_LEN
+	.core.__LABEL__.ZXBASIC_USER_DATA EQU .core.ZXBASIC_USER_DATA
+.core.ZXBASIC_USER_DATA_END:
+.core.__MAIN_PROGRAM__:
+	call _test
+	ld hl, 0
+	ld b, h
+	ld c, l
+.core.__END_PROGRAM:
+	di
+	ld hl, (.core.__CALL_BACK__)
+	ld sp, hl
+	exx
+	pop hl
+	exx
+	pop iy
+	pop ix
+	ei
+	ret
+_Incr:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld a, (hl)
+	inc a
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld (hl), a
+_Incr__leave:
+	ld sp, ix
+	pop ix
+	exx
+	pop hl
+	ex (sp), hl
+	exx
+	ret
+_test:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld hl, 0
+	push hl
+	push hl
+	push hl
+	ld hl, .LABEL.__LABEL1
+	push hl
+	ld hl, -6
+	ld de, .LABEL.__LABEL0
+	ld bc, 3
+	call .core.__ALLOC_INITIALIZED_LOCAL_ARRAY
+	ld hl, 1
+	push hl
+	push ix
+	pop hl
+	ld de, -6
+	add hl, de
+	call .core.__ARRAY
+	push hl
+	call _Incr
+	ld l, (ix-4)
+	ld h, (ix-3)
+	inc hl
+	ld a, (hl)
+	ld (0), a
+_test__leave:
+	ex af, af'
+	exx
+	ld l, (ix-4)
+	ld h, (ix-3)
+	call .core.__MEM_FREE
+	ex af, af'
+	exx
+	ld sp, ix
+	pop ix
+	ret
+	;; --- end of user code ---
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	; -------------------------------------------------------------------
+	; Simple array Index routine
+	; Number of total indexes dimensions - 1 at beginning of memory
+	; HL = Start of array memory (First two bytes contains N-1 dimensions)
+	; Dimension values on the stack, (top of the stack, highest dimension)
+	; E.g. A(2, 4) -> PUSH <4>; PUSH <2>
+	; For any array of N dimension A(aN-1, ..., a1, a0)
+	; and dimensions D[bN-1, ..., b1, b0], the offset is calculated as
+	; O = [a0 + b0 * (a1 + b1 * (a2 + ... bN-2(aN-1)))]
+; What I will do here is to calculate the following sequence:
+	; ((aN-1 * bN-2) + aN-2) * bN-3 + ...
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	;; Performs a faster multiply for little 16bit numbs
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/mul16.asm"
+	    push namespace core
+__MUL16:	; Mutiplies HL with the last value stored into de stack
+	    ; Works for both signed and unsigned
+	    PROC
+	    LOCAL __MUL16LOOP
+	    LOCAL __MUL16NOADD
+	    ex de, hl
+	    pop hl		; Return address
+	    ex (sp), hl ; CALLEE caller convention
+__MUL16_FAST:
+	    ld b, 16
+	    ld a, h
+	    ld c, l
+	    ld hl, 0
+__MUL16LOOP:
+	    add hl, hl  ; hl << 1
+	    sla c
+	    rla         ; a,c << 1
+	    jp nc, __MUL16NOADD
+	    add hl, de
+__MUL16NOADD:
+	    djnz __MUL16LOOP
+	    ret	; Result in hl (16 lower bits)
+	    ENDP
+	    pop namespace
+#line 3 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	    push namespace core
+__FMUL16:
+	    xor a
+	    or h
+	    jp nz, __MUL16_FAST
+	    or l
+	    ret z
+	    cp 33
+	    jp nc, __MUL16_FAST
+	    ld b, l
+	    ld l, h  ; HL = 0
+1:
+	    add hl, de
+	    djnz 1b
+	    ret
+	    pop namespace
+#line 20 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+#line 24 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    push namespace core
+__ARRAY_PTR:   ;; computes an array offset from a pointer
+	    ld c, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, c    ;; HL <-- [HL]
+__ARRAY:
+	    PROC
+	    LOCAL LOOP
+	    LOCAL ARRAY_END
+	    LOCAL TMP_ARR_PTR            ; Ptr to Array DATA region. Stored temporarily
+	    LOCAL LBOUND_PTR, UBOUND_PTR ; LBound and UBound PTR indexes
+	    LOCAL RET_ADDR               ; Contains the return address popped from the stack
+	LBOUND_PTR EQU 23698           ; Uses MEMBOT as a temporary variable
+	UBOUND_PTR EQU LBOUND_PTR + 2  ; Next 2 bytes for UBOUND PTR
+	RET_ADDR EQU UBOUND_PTR + 2    ; Next 2 bytes for RET_ADDR
+	TMP_ARR_PTR EQU RET_ADDR + 2   ; Next 2 bytes for TMP_ARR_PTR
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    inc hl      ; DE <-- PTR to Dim sizes table
+	    ld (TMP_ARR_PTR), hl  ; HL = Array __DATA__.__PTR__
+	    inc hl
+	    inc hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)  ; BC <-- Array __LBOUND__ PTR
+	    ld (LBOUND_PTR), bc  ; Store it for later
+#line 66 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl   ; HL <-- PTR to Dim sizes table, DE <-- dummy
+	    ex (sp), hl	; Return address in HL, PTR Dim sizes table onto Stack
+	    ld (RET_ADDR), hl ; Stores it for later
+	    exx
+	    pop hl		; Will use H'L' as the pointer to Dim sizes table
+	    ld c, (hl)	; Loads Number of dimensions from (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl		; Ready
+	    exx
+	    ld hl, 0	; HL = Element Offset "accumulator"
+LOOP:
+	    ex de, hl   ; DE = Element Offset
+	    ld hl, (LBOUND_PTR)
+	    ld a, h
+	    or l
+	    ld b, h
+	    ld c, l
+	    jr z, 1f
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl
+	    ld (LBOUND_PTR), hl
+1:
+	    pop hl      ; Get next index (Ai) from the stack
+	    sbc hl, bc  ; Subtract LBOUND
+#line 116 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    add hl, de	; Adds current index
+	    exx			; Checks if B'C' = 0
+	    ld a, b		; Which means we must exit (last element is not multiplied by anything)
+	    or c
+	    jr z, ARRAY_END		; if B'Ci == 0 we are done
+	    dec bc				; Decrements loop counter
+	    ld e, (hl)			; Loads next dimension size into D'E'
+	    inc hl
+	    ld d, (hl)
+	    inc hl
+	    push de
+	    exx
+	    pop de				; DE = Max bound Number (i-th dimension)
+	    call __FMUL16        ; HL <= HL * DE mod 65536
+	    jp LOOP
+ARRAY_END:
+	    ld a, (hl)
+	    exx
+#line 146 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    LOCAL ARRAY_SIZE_LOOP
+	    ex de, hl
+	    ld hl, 0
+	    ld b, a
+ARRAY_SIZE_LOOP:
+	    add hl, de
+	    djnz ARRAY_SIZE_LOOP
+#line 156 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl
+	    ld hl, (TMP_ARR_PTR)
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a
+	    add hl, de  ; Adds element start
+	    ld de, (RET_ADDR)
+	    push de
+	    ret
+	    ENDP
+	    pop namespace
+#line 76 "arch/zx48k/arr_elem_by_ref02.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the MIT license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the MIT license on the internet
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the MIT license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the MIT license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be freed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/error.asm"
+	; Simple error control routines
+; vim:ts=4:et:
+	    push namespace core
+	ERR_NR    EQU    23610    ; Error code system variable
+	; Error code definitions (as in ZX spectrum manual)
+; Set error code with:
+	;    ld a, ERROR_CODE
+	;    ld (ERR_NR), a
+	ERROR_Ok                EQU    -1
+	ERROR_SubscriptWrong    EQU     2
+	ERROR_OutOfMemory       EQU     3
+	ERROR_OutOfScreen       EQU     4
+	ERROR_NumberTooBig      EQU     5
+	ERROR_InvalidArg        EQU     9
+	ERROR_IntOutOfRange     EQU    10
+	ERROR_NonsenseInBasic   EQU    11
+	ERROR_InvalidFileName   EQU    14
+	ERROR_InvalidColour     EQU    19
+	ERROR_BreakIntoProgram  EQU    20
+	ERROR_TapeLoadingErr    EQU    26
+	; Raises error using RST #8
+__ERROR:
+	    ld (__ERROR_CODE), a
+	    rst 8
+__ERROR_CODE:
+	    nop
+	    ret
+	; Sets the error system variable, but keeps running.
+	; Usually this instruction if followed by the END intermediate instruction.
+__STOP:
+	    ld (ERR_NR), a
+	    ret
+	    pop namespace
+#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/heapinit.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	;  __MEM_INIT must be called to initalize this library with the
+	; standard parameters
+	; ---------------------------------------------------------------------
+	    push namespace core
+__MEM_INIT: ; Initializes the library using (RAMTOP) as start, and
+	    ld hl, ZXBASIC_MEM_HEAP  ; Change this with other address of heap start
+	    ld de, ZXBASIC_HEAP_SIZE ; Change this with your size
+	; ---------------------------------------------------------------------
+	;  __MEM_INIT2 initalizes this library
+; Parameters:
+;   HL : Memory address of 1st byte of the memory heap
+;   DE : Length in bytes of the Memory Heap
+	; ---------------------------------------------------------------------
+__MEM_INIT2:
+	    ; HL as TOP
+	    PROC
+	    dec de
+	    dec de
+	    dec de
+	    dec de        ; DE = length - 4; HL = start
+	    ; This is done, because we require 4 bytes for the empty dummy-header block
+	    xor a
+	    ld (hl), a
+	    inc hl
+    ld (hl), a ; First "free" block is a header: size=0, Pointer=&(Block) + 4
+	    inc hl
+	    ld b, h
+	    ld c, l
+	    inc bc
+	    inc bc      ; BC = starts of next block
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b
+	    inc hl      ; Pointer to next block
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl      ; Block size (should be length - 4 at start); This block contains all the available memory
+	    ld (hl), a ; NULL (0000h) ; No more blocks (a list with a single block)
+	    inc hl
+	    ld (hl), a
+	    ld a, 201
+	    ld (__MEM_INIT), a; "Pokes" with a RET so ensure this routine is not called again
+	    ret
+	    ENDP
+	    pop namespace
+#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	; ---------------------------------------------------------------------
+	; MEM_ALLOC
+	;  Allocates a block of memory in the heap.
+	;
+	; Parameters
+	;  BC = Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	; ---------------------------------------------------------------------
+	    push namespace core
+MEM_ALLOC:
+__MEM_ALLOC: ; Returns the 1st free block found of the given length (in BC)
+	    PROC
+	    LOCAL __MEM_LOOP
+	    LOCAL __MEM_DONE
+	    LOCAL __MEM_SUBTRACT
+	    LOCAL __MEM_START
+	    LOCAL TEMP, TEMP0
+	TEMP EQU TEMP0 + 1
+	    ld hl, 0
+	    ld (TEMP), hl
+__MEM_START:
+	    ld hl, ZXBASIC_MEM_HEAP  ; This label point to the heap start
+	    inc bc
+	    inc bc  ; BC = BC + 2 ; block size needs 2 extra bytes for hidden pointer
+__MEM_LOOP:  ; Loads lengh at (HL, HL+). If Lenght >= BC, jump to __MEM_DONE
+	    ld a, h ;  HL = NULL (No memory available?)
+	    or l
+#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	    ret z ; NULL
+#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	    ; HL = Pointer to Free block
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    inc hl          ; DE = Block Length
+	    push hl         ; HL = *pointer to -> next block
+	    ex de, hl
+	    or a            ; CF = 0
+	    sbc hl, bc      ; FREE >= BC (Length)  (HL = BlockLength - Length)
+	    jp nc, __MEM_DONE
+	    pop hl
+	    ld (TEMP), hl
+	    ex de, hl
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    ex de, hl
+	    jp __MEM_LOOP
+__MEM_DONE:  ; A free block has been found.
+	    ; Check if at least 4 bytes remains free (HL >= 4)
+	    push hl
+	    exx  ; exx to preserve bc
+	    pop hl
+	    ld bc, 4
+	    or a
+	    sbc hl, bc
+	    exx
+	    jp nc, __MEM_SUBTRACT
+	    ; At this point...
+	    ; less than 4 bytes remains free. So we return this block entirely
+	    ; We must link the previous block with the next to this one
+	    ; (DE) => Pointer to next block
+	    ; (TEMP) => &(previous->next)
+	    pop hl     ; Discard current block pointer
+	    push de
+	    ex de, hl  ; DE = Previous block pointer; (HL) = Next block pointer
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a    ; HL = (HL)
+	    ex de, hl  ; HL = Previous block pointer; DE = Next block pointer
+TEMP0:
+	    ld hl, 0   ; Pre-previous block pointer
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d ; LINKED
+	    pop hl ; Returning block.
+	    ret
+__MEM_SUBTRACT:
+	    ; At this point we have to store HL value (Length - BC) into (DE - 2)
+	    ex de, hl
+	    dec hl
+	    ld (hl), d
+	    dec hl
+	    ld (hl), e ; Store new block length
+	    add hl, de ; New length + DE => free-block start
+	    pop de     ; Remove previous HL off the stack
+	    ld (hl), c ; Store length on its 1st word
+	    inc hl
+	    ld (hl), b
+	    inc hl     ; Return hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
+	; ---------------------------------------------------------------------
+	; MEM_CALLOC
+	;  Allocates a block of memory in the heap, and clears it filling it
+	;  with 0 bytes
+	;
+	; Parameters
+	;  BC = Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	; ---------------------------------------------------------------------
+	    push namespace core
+__MEM_CALLOC:
+	    push bc
+	    call __MEM_ALLOC
+	    pop bc
+	    ld a, h
+	    or l
+	    ret z  ; No memory
+	    ld (hl), 0
+	    dec bc
+	    ld a, b
+	    or c
+	    ret z  ; Already filled (1 byte-length block)
+	    ld d, h
+	    ld e, l
+	    inc de
+	    push hl
+	    ldir
+	    pop hl
+	    ret
+	    pop namespace
+#line 3 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
+	; ---------------------------------------------------------------------
+	; __ALLOC_LOCAL_ARRAY
+	;  Allocates an array element area in the heap, and clears it filling it
+	;  with 0 bytes
+	;
+	; Parameters
+	;  HL = Offset to be added to IX => HL = IX + HL
+	;  BC = Length of the element area = n.elements * size(element)
+	;  DE = PTR to the index table
+	;
+; Returns:
+	;  HL = (IX + HL) + 4
+	; ---------------------------------------------------------------------
+	    push namespace core
+__ALLOC_LOCAL_ARRAY:
+	    push de
+	    push ix
+	    pop de
+	    add hl, de  ; hl = ix + hl
+	    pop de
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl
+	    push hl
+	    call __MEM_CALLOC
+	    pop de
+	    ex de, hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    ret
+	; ---------------------------------------------------------------------
+	; __ALLOC_INITIALIZED_LOCAL_ARRAY
+	;  Allocates an array element area in the heap, and clears it filling it
+	;  with data whose pointer (PTR) is in the stack
+	;
+	; Parameters
+	;  HL = Offset to be added to IX => HL = IX + HL
+	;  BC = Length of the element area = n.elements * size(element)
+	;  DE = PTR to the index table
+	;  [SP + 2] = PTR to the element area
+	;
+; Returns:
+	;  HL = (IX + HL) + 4
+	; ---------------------------------------------------------------------
+__ALLOC_INITIALIZED_LOCAL_ARRAY:
+	    push bc
+	    call __ALLOC_LOCAL_ARRAY
+	    pop bc
+	    ;; Swaps [SP], [SP + 2]
+	    exx
+	    pop hl       ; HL <- RET address
+	    ex (sp), hl  ; HL <- Data table, [SP] <- RET address
+	    push hl      ; [SP] <- Data table
+	    exx
+	    ex (sp), hl  ; HL = Data table, (SP) = (IX + HL + 4) - start of array address lbound
+	    ; HL = data table
+	    ; BC = length
+	    ; DE = new data area
+	    ldir
+	    pop hl  ; HL = addr of LBound area if used
+	    ret
+#line 142 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
+	    pop namespace
+#line 77 "arch/zx48k/arr_elem_by_ref02.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/free.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_FREE
+	;  Frees a block of memory
+	;
+; Parameters:
+	;  HL = Pointer to the block to be freed. If HL is NULL (0) nothing
+	;  is done
+	; ---------------------------------------------------------------------
+	    push namespace core
+MEM_FREE:
+__MEM_FREE: ; Frees the block pointed by HL
+	    ; HL DE BC & AF modified
+	    PROC
+	    LOCAL __MEM_LOOP2
+	    LOCAL __MEM_LINK_PREV
+	    LOCAL __MEM_JOIN_TEST
+	    LOCAL __MEM_BLOCK_JOIN
+	    ld a, h
+	    or l
+	    ret z       ; Return if NULL pointer
+	    dec hl
+	    dec hl
+	    ld b, h
+	    ld c, l    ; BC = Block pointer
+	    ld hl, ZXBASIC_MEM_HEAP  ; This label point to the heap start
+__MEM_LOOP2:
+	    inc hl
+	    inc hl     ; Next block ptr
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl) ; Block next ptr
+	    ex de, hl  ; DE = &(block->next); HL = block->next
+	    ld a, h    ; HL == NULL?
+	    or l
+	    jp z, __MEM_LINK_PREV; if so, link with previous
+	    or a       ; Clear carry flag
+	    sbc hl, bc ; Carry if BC > HL => This block if before
+	    add hl, bc ; Restores HL, preserving Carry flag
+	    jp c, __MEM_LOOP2 ; This block is before. Keep searching PASS the block
+	;------ At this point current HL is PAST BC, so we must link (DE) with BC, and HL in BC->next
+__MEM_LINK_PREV:    ; Link (DE) with BC, and BC->next with HL
+	    ex de, hl
+	    push hl
+	    dec hl
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b ; (DE) <- BC
+	    ld h, b    ; HL <- BC (Free block ptr)
+	    ld l, c
+	    inc hl     ; Skip block length (2 bytes)
+	    inc hl
+	    ld (hl), e ; Block->next = DE
+	    inc hl
+	    ld (hl), d
+	    ; --- LINKED ; HL = &(BC->next) + 2
+	    call __MEM_JOIN_TEST
+	    pop hl
+__MEM_JOIN_TEST:   ; Checks for fragmented contiguous blocks and joins them
+	    ; hl = Ptr to current block + 2
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)
+	    dec hl
+	    ld b, (hl) ; Loads block length into BC
+	    dec hl
+	    ld c, (hl) ;
+	    push hl    ; Saves it for later
+	    add hl, bc ; Adds its length. If HL == DE now, it must be joined
+	    or a
+	    sbc hl, de ; If Z, then HL == DE => We must join
+	    pop hl
+	    ret nz
+__MEM_BLOCK_JOIN:  ; Joins current block (pointed by HL) with next one (pointed by DE). HL->length already in BC
+	    push hl    ; Saves it for later
+	    ex de, hl
+	    ld e, (hl) ; DE -> block->next->length
+	    inc hl
+	    ld d, (hl)
+	    inc hl
+	    ex de, hl  ; DE = &(block->next)
+	    add hl, bc ; HL = Total Length
+	    ld b, h
+	    ld c, l    ; BC = Total Length
+	    ex de, hl
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl) ; DE = block->next
+	    pop hl     ; Recovers Pointer to block
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b ; Length Saved
+	    inc hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d ; Next saved
+	    ret
+	    ENDP
+	    pop namespace
+#line 78 "arch/zx48k/arr_elem_by_ref02.bas"
+.LABEL.__LABEL0:
+	DEFB 00h
+	DEFB 00h
+	DEFB 01h
+.LABEL.__LABEL1:
+	DEFB 01h
+	DEFB 02h
+	DEFB 03h
+	END
diff --git a/tests/functional/arch/zx48k/arr_elem_by_ref02.bas b/tests/functional/arch/zx48k/arr_elem_by_ref02.bas
new file mode 100644
index 000000000..be588fc5f
--- /dev/null
+++ b/tests/functional/arch/zx48k/arr_elem_by_ref02.bas
@@ -0,0 +1,14 @@
+REM Test passing an local array element by ref
+
+
+SUB Incr(ByRef x As UByte)
+  LET x = x + 1
+END SUB
+
+SUB test
+  DIM a(2) As UByte => {1, 2, 3}
+  Incr(a(1))
+  POKE 0, a(1)
+END SUB
+
+test
diff --git a/tests/functional/arch/zx48k/arr_elem_by_ref03.asm b/tests/functional/arch/zx48k/arr_elem_by_ref03.asm
new file mode 100644
index 000000000..3ddbde69a
--- /dev/null
+++ b/tests/functional/arch/zx48k/arr_elem_by_ref03.asm
@@ -0,0 +1,856 @@
+	org 32768
+.core.__START_PROGRAM:
+	di
+	push ix
+	push iy
+	exx
+	push hl
+	exx
+	ld (.core.__CALL_BACK__), sp
+	ei
+	call .core.__MEM_INIT
+	jp .core.__MAIN_PROGRAM__
+.core.__CALL_BACK__:
+	DEFW 0
+.core.ZXBASIC_USER_DATA:
+	; Defines HEAP SIZE
+.core.ZXBASIC_HEAP_SIZE EQU 4768
+.core.ZXBASIC_MEM_HEAP:
+	DEFS 4768
+	; Defines USER DATA Length in bytes
+.core.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_END - .core.ZXBASIC_USER_DATA
+	.core.__LABEL__.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_LEN
+	.core.__LABEL__.ZXBASIC_USER_DATA EQU .core.ZXBASIC_USER_DATA
+.core.ZXBASIC_USER_DATA_END:
+.core.__MAIN_PROGRAM__:
+	call _test
+	ld hl, 0
+	ld b, h
+	ld c, l
+.core.__END_PROGRAM:
+	di
+	ld hl, (.core.__CALL_BACK__)
+	ld sp, hl
+	exx
+	pop hl
+	exx
+	pop iy
+	pop ix
+	ei
+	ret
+_Incr:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld a, (hl)
+	inc a
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld (hl), a
+_Incr__leave:
+	ld sp, ix
+	pop ix
+	exx
+	pop hl
+	ex (sp), hl
+	exx
+	ret
+_ProxyFunc:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld l, (ix+4)
+	ld h, (ix+5)
+	push hl
+	call _Incr
+_ProxyFunc__leave:
+	ld sp, ix
+	pop ix
+	exx
+	pop hl
+	ex (sp), hl
+	exx
+	ret
+_test:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld hl, 0
+	push hl
+	push hl
+	push hl
+	ld hl, .LABEL.__LABEL1
+	push hl
+	ld hl, -6
+	ld de, .LABEL.__LABEL0
+	ld bc, 3
+	call .core.__ALLOC_INITIALIZED_LOCAL_ARRAY
+	ld hl, 1
+	push hl
+	push ix
+	pop hl
+	ld de, -6
+	add hl, de
+	call .core.__ARRAY
+	push hl
+	call _ProxyFunc
+	ld l, (ix-4)
+	ld h, (ix-3)
+	inc hl
+	ld a, (hl)
+	ld (0), a
+_test__leave:
+	ex af, af'
+	exx
+	ld l, (ix-4)
+	ld h, (ix-3)
+	call .core.__MEM_FREE
+	ex af, af'
+	exx
+	ld sp, ix
+	pop ix
+	ret
+	;; --- end of user code ---
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	; -------------------------------------------------------------------
+	; Simple array Index routine
+	; Number of total indexes dimensions - 1 at beginning of memory
+	; HL = Start of array memory (First two bytes contains N-1 dimensions)
+	; Dimension values on the stack, (top of the stack, highest dimension)
+	; E.g. A(2, 4) -> PUSH <4>; PUSH <2>
+	; For any array of N dimension A(aN-1, ..., a1, a0)
+	; and dimensions D[bN-1, ..., b1, b0], the offset is calculated as
+	; O = [a0 + b0 * (a1 + b1 * (a2 + ... bN-2(aN-1)))]
+; What I will do here is to calculate the following sequence:
+	; ((aN-1 * bN-2) + aN-2) * bN-3 + ...
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	;; Performs a faster multiply for little 16bit numbs
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/mul16.asm"
+	    push namespace core
+__MUL16:	; Mutiplies HL with the last value stored into de stack
+	    ; Works for both signed and unsigned
+	    PROC
+	    LOCAL __MUL16LOOP
+	    LOCAL __MUL16NOADD
+	    ex de, hl
+	    pop hl		; Return address
+	    ex (sp), hl ; CALLEE caller convention
+__MUL16_FAST:
+	    ld b, 16
+	    ld a, h
+	    ld c, l
+	    ld hl, 0
+__MUL16LOOP:
+	    add hl, hl  ; hl << 1
+	    sla c
+	    rla         ; a,c << 1
+	    jp nc, __MUL16NOADD
+	    add hl, de
+__MUL16NOADD:
+	    djnz __MUL16LOOP
+	    ret	; Result in hl (16 lower bits)
+	    ENDP
+	    pop namespace
+#line 3 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	    push namespace core
+__FMUL16:
+	    xor a
+	    or h
+	    jp nz, __MUL16_FAST
+	    or l
+	    ret z
+	    cp 33
+	    jp nc, __MUL16_FAST
+	    ld b, l
+	    ld l, h  ; HL = 0
+1:
+	    add hl, de
+	    djnz 1b
+	    ret
+	    pop namespace
+#line 20 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+#line 24 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    push namespace core
+__ARRAY_PTR:   ;; computes an array offset from a pointer
+	    ld c, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, c    ;; HL <-- [HL]
+__ARRAY:
+	    PROC
+	    LOCAL LOOP
+	    LOCAL ARRAY_END
+	    LOCAL TMP_ARR_PTR            ; Ptr to Array DATA region. Stored temporarily
+	    LOCAL LBOUND_PTR, UBOUND_PTR ; LBound and UBound PTR indexes
+	    LOCAL RET_ADDR               ; Contains the return address popped from the stack
+	LBOUND_PTR EQU 23698           ; Uses MEMBOT as a temporary variable
+	UBOUND_PTR EQU LBOUND_PTR + 2  ; Next 2 bytes for UBOUND PTR
+	RET_ADDR EQU UBOUND_PTR + 2    ; Next 2 bytes for RET_ADDR
+	TMP_ARR_PTR EQU RET_ADDR + 2   ; Next 2 bytes for TMP_ARR_PTR
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    inc hl      ; DE <-- PTR to Dim sizes table
+	    ld (TMP_ARR_PTR), hl  ; HL = Array __DATA__.__PTR__
+	    inc hl
+	    inc hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)  ; BC <-- Array __LBOUND__ PTR
+	    ld (LBOUND_PTR), bc  ; Store it for later
+#line 66 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl   ; HL <-- PTR to Dim sizes table, DE <-- dummy
+	    ex (sp), hl	; Return address in HL, PTR Dim sizes table onto Stack
+	    ld (RET_ADDR), hl ; Stores it for later
+	    exx
+	    pop hl		; Will use H'L' as the pointer to Dim sizes table
+	    ld c, (hl)	; Loads Number of dimensions from (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl		; Ready
+	    exx
+	    ld hl, 0	; HL = Element Offset "accumulator"
+LOOP:
+	    ex de, hl   ; DE = Element Offset
+	    ld hl, (LBOUND_PTR)
+	    ld a, h
+	    or l
+	    ld b, h
+	    ld c, l
+	    jr z, 1f
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl
+	    ld (LBOUND_PTR), hl
+1:
+	    pop hl      ; Get next index (Ai) from the stack
+	    sbc hl, bc  ; Subtract LBOUND
+#line 116 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    add hl, de	; Adds current index
+	    exx			; Checks if B'C' = 0
+	    ld a, b		; Which means we must exit (last element is not multiplied by anything)
+	    or c
+	    jr z, ARRAY_END		; if B'Ci == 0 we are done
+	    dec bc				; Decrements loop counter
+	    ld e, (hl)			; Loads next dimension size into D'E'
+	    inc hl
+	    ld d, (hl)
+	    inc hl
+	    push de
+	    exx
+	    pop de				; DE = Max bound Number (i-th dimension)
+	    call __FMUL16        ; HL <= HL * DE mod 65536
+	    jp LOOP
+ARRAY_END:
+	    ld a, (hl)
+	    exx
+#line 146 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    LOCAL ARRAY_SIZE_LOOP
+	    ex de, hl
+	    ld hl, 0
+	    ld b, a
+ARRAY_SIZE_LOOP:
+	    add hl, de
+	    djnz ARRAY_SIZE_LOOP
+#line 156 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl
+	    ld hl, (TMP_ARR_PTR)
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a
+	    add hl, de  ; Adds element start
+	    ld de, (RET_ADDR)
+	    push de
+	    ret
+	    ENDP
+	    pop namespace
+#line 92 "arch/zx48k/arr_elem_by_ref03.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the MIT license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the MIT license on the internet
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the MIT license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the MIT license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be freed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/error.asm"
+	; Simple error control routines
+; vim:ts=4:et:
+	    push namespace core
+	ERR_NR    EQU    23610    ; Error code system variable
+	; Error code definitions (as in ZX spectrum manual)
+; Set error code with:
+	;    ld a, ERROR_CODE
+	;    ld (ERR_NR), a
+	ERROR_Ok                EQU    -1
+	ERROR_SubscriptWrong    EQU     2
+	ERROR_OutOfMemory       EQU     3
+	ERROR_OutOfScreen       EQU     4
+	ERROR_NumberTooBig      EQU     5
+	ERROR_InvalidArg        EQU     9
+	ERROR_IntOutOfRange     EQU    10
+	ERROR_NonsenseInBasic   EQU    11
+	ERROR_InvalidFileName   EQU    14
+	ERROR_InvalidColour     EQU    19
+	ERROR_BreakIntoProgram  EQU    20
+	ERROR_TapeLoadingErr    EQU    26
+	; Raises error using RST #8
+__ERROR:
+	    ld (__ERROR_CODE), a
+	    rst 8
+__ERROR_CODE:
+	    nop
+	    ret
+	; Sets the error system variable, but keeps running.
+	; Usually this instruction if followed by the END intermediate instruction.
+__STOP:
+	    ld (ERR_NR), a
+	    ret
+	    pop namespace
+#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/heapinit.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	;  __MEM_INIT must be called to initalize this library with the
+	; standard parameters
+	; ---------------------------------------------------------------------
+	    push namespace core
+__MEM_INIT: ; Initializes the library using (RAMTOP) as start, and
+	    ld hl, ZXBASIC_MEM_HEAP  ; Change this with other address of heap start
+	    ld de, ZXBASIC_HEAP_SIZE ; Change this with your size
+	; ---------------------------------------------------------------------
+	;  __MEM_INIT2 initalizes this library
+; Parameters:
+;   HL : Memory address of 1st byte of the memory heap
+;   DE : Length in bytes of the Memory Heap
+	; ---------------------------------------------------------------------
+__MEM_INIT2:
+	    ; HL as TOP
+	    PROC
+	    dec de
+	    dec de
+	    dec de
+	    dec de        ; DE = length - 4; HL = start
+	    ; This is done, because we require 4 bytes for the empty dummy-header block
+	    xor a
+	    ld (hl), a
+	    inc hl
+    ld (hl), a ; First "free" block is a header: size=0, Pointer=&(Block) + 4
+	    inc hl
+	    ld b, h
+	    ld c, l
+	    inc bc
+	    inc bc      ; BC = starts of next block
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b
+	    inc hl      ; Pointer to next block
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl      ; Block size (should be length - 4 at start); This block contains all the available memory
+	    ld (hl), a ; NULL (0000h) ; No more blocks (a list with a single block)
+	    inc hl
+	    ld (hl), a
+	    ld a, 201
+	    ld (__MEM_INIT), a; "Pokes" with a RET so ensure this routine is not called again
+	    ret
+	    ENDP
+	    pop namespace
+#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	; ---------------------------------------------------------------------
+	; MEM_ALLOC
+	;  Allocates a block of memory in the heap.
+	;
+	; Parameters
+	;  BC = Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	; ---------------------------------------------------------------------
+	    push namespace core
+MEM_ALLOC:
+__MEM_ALLOC: ; Returns the 1st free block found of the given length (in BC)
+	    PROC
+	    LOCAL __MEM_LOOP
+	    LOCAL __MEM_DONE
+	    LOCAL __MEM_SUBTRACT
+	    LOCAL __MEM_START
+	    LOCAL TEMP, TEMP0
+	TEMP EQU TEMP0 + 1
+	    ld hl, 0
+	    ld (TEMP), hl
+__MEM_START:
+	    ld hl, ZXBASIC_MEM_HEAP  ; This label point to the heap start
+	    inc bc
+	    inc bc  ; BC = BC + 2 ; block size needs 2 extra bytes for hidden pointer
+__MEM_LOOP:  ; Loads lengh at (HL, HL+). If Lenght >= BC, jump to __MEM_DONE
+	    ld a, h ;  HL = NULL (No memory available?)
+	    or l
+#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	    ret z ; NULL
+#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	    ; HL = Pointer to Free block
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    inc hl          ; DE = Block Length
+	    push hl         ; HL = *pointer to -> next block
+	    ex de, hl
+	    or a            ; CF = 0
+	    sbc hl, bc      ; FREE >= BC (Length)  (HL = BlockLength - Length)
+	    jp nc, __MEM_DONE
+	    pop hl
+	    ld (TEMP), hl
+	    ex de, hl
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    ex de, hl
+	    jp __MEM_LOOP
+__MEM_DONE:  ; A free block has been found.
+	    ; Check if at least 4 bytes remains free (HL >= 4)
+	    push hl
+	    exx  ; exx to preserve bc
+	    pop hl
+	    ld bc, 4
+	    or a
+	    sbc hl, bc
+	    exx
+	    jp nc, __MEM_SUBTRACT
+	    ; At this point...
+	    ; less than 4 bytes remains free. So we return this block entirely
+	    ; We must link the previous block with the next to this one
+	    ; (DE) => Pointer to next block
+	    ; (TEMP) => &(previous->next)
+	    pop hl     ; Discard current block pointer
+	    push de
+	    ex de, hl  ; DE = Previous block pointer; (HL) = Next block pointer
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a    ; HL = (HL)
+	    ex de, hl  ; HL = Previous block pointer; DE = Next block pointer
+TEMP0:
+	    ld hl, 0   ; Pre-previous block pointer
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d ; LINKED
+	    pop hl ; Returning block.
+	    ret
+__MEM_SUBTRACT:
+	    ; At this point we have to store HL value (Length - BC) into (DE - 2)
+	    ex de, hl
+	    dec hl
+	    ld (hl), d
+	    dec hl
+	    ld (hl), e ; Store new block length
+	    add hl, de ; New length + DE => free-block start
+	    pop de     ; Remove previous HL off the stack
+	    ld (hl), c ; Store length on its 1st word
+	    inc hl
+	    ld (hl), b
+	    inc hl     ; Return hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
+	; ---------------------------------------------------------------------
+	; MEM_CALLOC
+	;  Allocates a block of memory in the heap, and clears it filling it
+	;  with 0 bytes
+	;
+	; Parameters
+	;  BC = Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	; ---------------------------------------------------------------------
+	    push namespace core
+__MEM_CALLOC:
+	    push bc
+	    call __MEM_ALLOC
+	    pop bc
+	    ld a, h
+	    or l
+	    ret z  ; No memory
+	    ld (hl), 0
+	    dec bc
+	    ld a, b
+	    or c
+	    ret z  ; Already filled (1 byte-length block)
+	    ld d, h
+	    ld e, l
+	    inc de
+	    push hl
+	    ldir
+	    pop hl
+	    ret
+	    pop namespace
+#line 3 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
+	; ---------------------------------------------------------------------
+	; __ALLOC_LOCAL_ARRAY
+	;  Allocates an array element area in the heap, and clears it filling it
+	;  with 0 bytes
+	;
+	; Parameters
+	;  HL = Offset to be added to IX => HL = IX + HL
+	;  BC = Length of the element area = n.elements * size(element)
+	;  DE = PTR to the index table
+	;
+; Returns:
+	;  HL = (IX + HL) + 4
+	; ---------------------------------------------------------------------
+	    push namespace core
+__ALLOC_LOCAL_ARRAY:
+	    push de
+	    push ix
+	    pop de
+	    add hl, de  ; hl = ix + hl
+	    pop de
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl
+	    push hl
+	    call __MEM_CALLOC
+	    pop de
+	    ex de, hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    ret
+	; ---------------------------------------------------------------------
+	; __ALLOC_INITIALIZED_LOCAL_ARRAY
+	;  Allocates an array element area in the heap, and clears it filling it
+	;  with data whose pointer (PTR) is in the stack
+	;
+	; Parameters
+	;  HL = Offset to be added to IX => HL = IX + HL
+	;  BC = Length of the element area = n.elements * size(element)
+	;  DE = PTR to the index table
+	;  [SP + 2] = PTR to the element area
+	;
+; Returns:
+	;  HL = (IX + HL) + 4
+	; ---------------------------------------------------------------------
+__ALLOC_INITIALIZED_LOCAL_ARRAY:
+	    push bc
+	    call __ALLOC_LOCAL_ARRAY
+	    pop bc
+	    ;; Swaps [SP], [SP + 2]
+	    exx
+	    pop hl       ; HL <- RET address
+	    ex (sp), hl  ; HL <- Data table, [SP] <- RET address
+	    push hl      ; [SP] <- Data table
+	    exx
+	    ex (sp), hl  ; HL = Data table, (SP) = (IX + HL + 4) - start of array address lbound
+	    ; HL = data table
+	    ; BC = length
+	    ; DE = new data area
+	    ldir
+	    pop hl  ; HL = addr of LBound area if used
+	    ret
+#line 142 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
+	    pop namespace
+#line 93 "arch/zx48k/arr_elem_by_ref03.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/free.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_FREE
+	;  Frees a block of memory
+	;
+; Parameters:
+	;  HL = Pointer to the block to be freed. If HL is NULL (0) nothing
+	;  is done
+	; ---------------------------------------------------------------------
+	    push namespace core
+MEM_FREE:
+__MEM_FREE: ; Frees the block pointed by HL
+	    ; HL DE BC & AF modified
+	    PROC
+	    LOCAL __MEM_LOOP2
+	    LOCAL __MEM_LINK_PREV
+	    LOCAL __MEM_JOIN_TEST
+	    LOCAL __MEM_BLOCK_JOIN
+	    ld a, h
+	    or l
+	    ret z       ; Return if NULL pointer
+	    dec hl
+	    dec hl
+	    ld b, h
+	    ld c, l    ; BC = Block pointer
+	    ld hl, ZXBASIC_MEM_HEAP  ; This label point to the heap start
+__MEM_LOOP2:
+	    inc hl
+	    inc hl     ; Next block ptr
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl) ; Block next ptr
+	    ex de, hl  ; DE = &(block->next); HL = block->next
+	    ld a, h    ; HL == NULL?
+	    or l
+	    jp z, __MEM_LINK_PREV; if so, link with previous
+	    or a       ; Clear carry flag
+	    sbc hl, bc ; Carry if BC > HL => This block if before
+	    add hl, bc ; Restores HL, preserving Carry flag
+	    jp c, __MEM_LOOP2 ; This block is before. Keep searching PASS the block
+	;------ At this point current HL is PAST BC, so we must link (DE) with BC, and HL in BC->next
+__MEM_LINK_PREV:    ; Link (DE) with BC, and BC->next with HL
+	    ex de, hl
+	    push hl
+	    dec hl
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b ; (DE) <- BC
+	    ld h, b    ; HL <- BC (Free block ptr)
+	    ld l, c
+	    inc hl     ; Skip block length (2 bytes)
+	    inc hl
+	    ld (hl), e ; Block->next = DE
+	    inc hl
+	    ld (hl), d
+	    ; --- LINKED ; HL = &(BC->next) + 2
+	    call __MEM_JOIN_TEST
+	    pop hl
+__MEM_JOIN_TEST:   ; Checks for fragmented contiguous blocks and joins them
+	    ; hl = Ptr to current block + 2
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)
+	    dec hl
+	    ld b, (hl) ; Loads block length into BC
+	    dec hl
+	    ld c, (hl) ;
+	    push hl    ; Saves it for later
+	    add hl, bc ; Adds its length. If HL == DE now, it must be joined
+	    or a
+	    sbc hl, de ; If Z, then HL == DE => We must join
+	    pop hl
+	    ret nz
+__MEM_BLOCK_JOIN:  ; Joins current block (pointed by HL) with next one (pointed by DE). HL->length already in BC
+	    push hl    ; Saves it for later
+	    ex de, hl
+	    ld e, (hl) ; DE -> block->next->length
+	    inc hl
+	    ld d, (hl)
+	    inc hl
+	    ex de, hl  ; DE = &(block->next)
+	    add hl, bc ; HL = Total Length
+	    ld b, h
+	    ld c, l    ; BC = Total Length
+	    ex de, hl
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl) ; DE = block->next
+	    pop hl     ; Recovers Pointer to block
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b ; Length Saved
+	    inc hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d ; Next saved
+	    ret
+	    ENDP
+	    pop namespace
+#line 94 "arch/zx48k/arr_elem_by_ref03.bas"
+.LABEL.__LABEL0:
+	DEFB 00h
+	DEFB 00h
+	DEFB 01h
+.LABEL.__LABEL1:
+	DEFB 01h
+	DEFB 02h
+	DEFB 03h
+	END
diff --git a/tests/functional/arch/zx48k/arr_elem_by_ref03.bas b/tests/functional/arch/zx48k/arr_elem_by_ref03.bas
new file mode 100644
index 000000000..6ee818e06
--- /dev/null
+++ b/tests/functional/arch/zx48k/arr_elem_by_ref03.bas
@@ -0,0 +1,18 @@
+REM Test passing an local array element by param
+
+
+SUB Incr(ByRef x As UByte)
+  LET x = x + 1
+END SUB
+
+SUB ProxyFunc(ByRef x as UByte)
+  Incr(x)
+END SUB
+
+SUB test
+  DIM a(2) As UByte => {1, 2, 3}
+  ProxyFunc(a(1))
+  POKE 0, a(1)
+END SUB
+
+test
diff --git a/tests/functional/arch/zx48k/local_str_array1.asm b/tests/functional/arch/zx48k/local_str_array1.asm
index 774b6e4d1..18ac19255 100644
--- a/tests/functional/arch/zx48k/local_str_array1.asm
+++ b/tests/functional/arch/zx48k/local_str_array1.asm
@@ -61,8 +61,8 @@ _test:
 	ld de, -6
 	add hl, de
 	call .core.__ARRAY
-	pop de
-	call .core.__STORE_STR2
+	ld de, .LABEL.__LABEL0
+	call .core.__STORE_STR
 	ld hl, (_i)
 	push hl
 	push ix
@@ -259,7 +259,7 @@ ARRAY_SIZE_LOOP:
 	    pop namespace
 #line 74 "arch/zx48k/local_str_array1.bas"
 #line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -270,7 +270,7 @@ ARRAY_SIZE_LOOP:
 	; closed source programs).
 	;
 	; Please read the MIT license on the internet
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -364,8 +364,8 @@ __STOP:
 	    ld (ERR_NR), a
 	    ret
 	    pop namespace
-#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/heapinit.asm"
+#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/heapinit.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -472,7 +472,7 @@ __MEM_INIT2:
 	    ret
 	    ENDP
 	    pop namespace
-#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_ALLOC
 	;  Allocates a block of memory in the heap.
@@ -503,9 +503,9 @@ __MEM_START:
 __MEM_LOOP:  ; Loads lengh at (HL, HL+). If Lenght >= BC, jump to __MEM_DONE
 	    ld a, h ;  HL = NULL (No memory available?)
 	    or l
-#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ret z ; NULL
-#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ; HL = Pointer to Free block
 	    ld e, (hl)
 	    inc hl
@@ -570,7 +570,7 @@ __MEM_SUBTRACT:
 	    ret
 	    ENDP
 	    pop namespace
-#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_CALLOC
 	;  Allocates a block of memory in the heap, and clears it filling it
@@ -675,7 +675,7 @@ __ALLOC_INITIALIZED_LOCAL_ARRAY:
 	; This routine is in charge of freeing an array of strings from memory
 	; HL = Pointer to start of array in memory
 	; Top of the stack = Number of elements of the array
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/free.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/free.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -913,38 +913,253 @@ __LOADSTR:		; __FASTCALL__ entry
 	    pop hl	; Recovers destiny in hl as result
 	    ret
 	    pop namespace
-#line 78 "arch/zx48k/local_str_array1.bas"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr2.asm"
-	; Similar to __STORE_STR, but this one is called when
-	; the value of B$ if already duplicated onto the stack.
-	; So we needn't call STRASSING to create a duplication
-	; HL = address of string memory variable
-	; DE = address of 2n string. It just copies DE into (HL)
-	; 	freeing (HL) previously.
+#line 77 "arch/zx48k/local_str_array1.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+; vim:ts=4:et:sw=4
+	; Stores value of current string pointed by DE register into address pointed by HL
+	; Returns DE = Address pointer  (&a$)
+	; Returns HL = HL               (b$ => might be needed later to free it from the heap)
+	;
+	; e.g. => HL = _variableName    (DIM _variableName$)
+	;         DE = Address into the HEAP
+	;
+	; This function will resize (REALLOC) the space pointed by HL
+	; before copying the content of b$ into a$
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/realloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_REALLOC
+	;  Reallocates a block of memory in the heap.
+	;
+	; Parameters
+	;  HL = Pointer to the original block
+	;  BC = New Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	;
+; Notes:
+	;  If BC = 0, the block is freed, otherwise
+	;  the content of the original block is copied to the new one, and
+	;  the new size is adjusted. If BC < original length, the content
+	;  will be truncated. Otherwise, extra block content might contain
+	;  memory garbage.
+	;
+	; ---------------------------------------------------------------------
 	    push namespace core
-__PISTORE_STR2: ; Indirect store temporary string at (IX + BC)
+__REALLOC:    ; Reallocates block pointed by HL, with new length BC
+	    PROC
+	    LOCAL __REALLOC_END
+	    ld a, h
+	    or l
+	    jp z, __MEM_ALLOC    ; If HL == NULL, just do a malloc
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)    ; DE = First 2 bytes of HL block
+	    push hl
+	    exx
+	    pop de
+	    inc de        ; DE' <- HL + 2
+	    exx            ; DE' <- HL (Saves current pointer into DE')
+	    dec hl        ; HL = Block start
+	    push de
+	    push bc
+	    call __MEM_FREE        ; Frees current block
+	    pop bc
+	    push bc
+	    call __MEM_ALLOC    ; Gets a new block of length BC
+	    pop bc
+	    pop de
+	    ld a, h
+	    or l
+	    ret z        ; Return if HL == NULL (No memory)
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl        ; Recovers first 2 bytes in HL
+	    dec bc
+	    dec bc        ; BC = BC - 2 (Two bytes copied)
+	    ld a, b
+	    or c
+	    jp z, __REALLOC_END        ; Ret if nothing to copy (BC == 0)
+	    exx
+	    push de
+	    exx
+	    pop de        ; DE <- DE' ; Start of remaining block
+	    push hl        ; Saves current Block + 2 start
+    ex de, hl    ; Exchanges them: DE is destiny block
+	    ldir        ; Copies BC Bytes
+	    pop hl        ; Recovers Block + 2 start
+__REALLOC_END:
+	    dec hl        ; Set HL
+	    dec hl        ; To begin of block
+	    ret
+	    ENDP
+	    pop namespace
+#line 2 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+	; String library
+	    push namespace core
+__STRASSIGN: ; Performs a$ = b$ (HL = address of a$; DE = Address of b$)
+	    PROC
+	    LOCAL __STRREALLOC
+	    LOCAL __STRCONTINUE
+	    LOCAL __B_IS_NULL
+	    LOCAL __NOTHING_TO_COPY
+	    ld b, d
+	    ld c, e
+	    ld a, b
+	    or c
+	    jr z, __B_IS_NULL
+	    ex de, hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl		; BC = LEN(b$)
+	    ex de, hl	; DE = &b$
+__B_IS_NULL:		; Jumps here if B$ pointer is NULL
+	    inc bc
+	    inc bc		; BC = BC + 2  ; (LEN(b$) + 2 bytes for storing length)
+	    push de
+	    push hl
+	    ld a, h
+	    or l
+	    jr z, __STRREALLOC
+	    dec hl
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)	; DE = MEMBLOCKSIZE(a$)
+	    dec de
+	    dec de		; DE = DE - 2  ; (Membloksize takes 2 bytes for memblock length)
+	    ld h, b
+	    ld l, c		; HL = LEN(b$) + 2  => Minimum block size required
+	    ex de, hl	; Now HL = BLOCKSIZE(a$), DE = LEN(b$) + 2
+	    or a		; Prepare to subtract BLOCKSIZE(a$) - LEN(b$)
+	    sbc hl, de  ; Carry if len(b$) > Blocklen(a$)
+	    jr c, __STRREALLOC ; No need to realloc
+	    ; Need to reallocate at least to len(b$) + 2
+	    ex de, hl	; DE = Remaining bytes in a$ mem block.
+	    ld hl, 4
+	    sbc hl, de  ; if remaining bytes < 4 we can continue
+	    jr nc,__STRCONTINUE ; Otherwise, we realloc, to free some bytes
+__STRREALLOC:
+	    pop hl
+	    call __REALLOC	; Returns in HL a new pointer with BC bytes allocated
+	    push hl
+__STRCONTINUE:	;   Pops hl and de SWAPPED
+	    pop de	;	DE = &a$
+	    pop hl	; 	HL = &b$
+	    ld a, d		; Return if not enough memory for new length
+	    or e
+	    ret z		; Return if DE == NULL (0)
+__STRCPY:	; Copies string pointed by HL into string pointed by DE
+	    ; Returns DE as HL (new pointer)
+	    ld a, h
+	    or l
+	    jr z, __NOTHING_TO_COPY
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl
+	    inc bc
+	    inc bc
+	    push de
+	    ldir
+	    pop hl
+	    ret
+__NOTHING_TO_COPY:
+	    ex de, hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    dec hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 14 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+	    push namespace core
+__PISTORE_STR:          ; Indirect assignment at (IX + BC)
 	    push ix
 	    pop hl
 	    add hl, bc
-__ISTORE_STR2:
-	    ld c, (hl)  ; Dereferences HL
+__ISTORE_STR:           ; Indirect assignment, hl point to a pointer to a pointer to the heap!
+	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string variable address)
-__STORE_STR2:
-	    push hl
+	    ld l, c             ; HL = (HL)
+__STORE_STR:
+	    push de             ; Pointer to b$
+	    push hl             ; Pointer to a$
 	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string address)
-	    push de
-	    call __MEM_FREE
-	    pop de
-	    pop hl
+	    ld l, c             ; HL = (HL)
+	    call __STRASSIGN    ; HL (a$) = DE (b$); HL changed to a new dynamic memory allocation
+	    ex de, hl           ; DE = new address of a$
+	    pop hl              ; Recover variable memory address pointer
 	    ld (hl), e
 	    inc hl
-	    ld (hl), d
-	    dec hl		; HL points to mem address variable. This might be useful in the future.
+	    ld (hl), d          ; Stores a$ ptr into element ptr
+	    pop hl              ; Returns ptr to b$ in HL (Caller might needed to free it from memory)
 	    ret
 	    pop namespace
 #line 79 "arch/zx48k/local_str_array1.bas"
diff --git a/tests/functional/arch/zx48k/local_str_array2.asm b/tests/functional/arch/zx48k/local_str_array2.asm
index c3fdaed7f..9e4d7b1f9 100644
--- a/tests/functional/arch/zx48k/local_str_array2.asm
+++ b/tests/functional/arch/zx48k/local_str_array2.asm
@@ -72,8 +72,8 @@ _test:
 	ld de, -8
 	add hl, de
 	call .core.__ARRAY
-	pop de
-	call .core.__STORE_STR2
+	ld de, .LABEL.__LABEL0
+	call .core.__STORE_STR
 	ld l, (ix-2)
 	ld h, (ix-1)
 	push hl
@@ -271,7 +271,7 @@ ARRAY_SIZE_LOOP:
 	    pop namespace
 #line 89 "arch/zx48k/local_str_array2.bas"
 #line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -282,7 +282,7 @@ ARRAY_SIZE_LOOP:
 	; closed source programs).
 	;
 	; Please read the MIT license on the internet
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -376,8 +376,8 @@ __STOP:
 	    ld (ERR_NR), a
 	    ret
 	    pop namespace
-#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/heapinit.asm"
+#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/heapinit.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -484,7 +484,7 @@ __MEM_INIT2:
 	    ret
 	    ENDP
 	    pop namespace
-#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_ALLOC
 	;  Allocates a block of memory in the heap.
@@ -515,9 +515,9 @@ __MEM_START:
 __MEM_LOOP:  ; Loads lengh at (HL, HL+). If Lenght >= BC, jump to __MEM_DONE
 	    ld a, h ;  HL = NULL (No memory available?)
 	    or l
-#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ret z ; NULL
-#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ; HL = Pointer to Free block
 	    ld e, (hl)
 	    inc hl
@@ -582,7 +582,7 @@ __MEM_SUBTRACT:
 	    ret
 	    ENDP
 	    pop namespace
-#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_CALLOC
 	;  Allocates a block of memory in the heap, and clears it filling it
@@ -687,7 +687,7 @@ __ALLOC_INITIALIZED_LOCAL_ARRAY:
 	; This routine is in charge of freeing an array of strings from memory
 	; HL = Pointer to start of array in memory
 	; Top of the stack = Number of elements of the array
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/free.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/free.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -925,38 +925,253 @@ __LOADSTR:		; __FASTCALL__ entry
 	    pop hl	; Recovers destiny in hl as result
 	    ret
 	    pop namespace
-#line 93 "arch/zx48k/local_str_array2.bas"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr2.asm"
-	; Similar to __STORE_STR, but this one is called when
-	; the value of B$ if already duplicated onto the stack.
-	; So we needn't call STRASSING to create a duplication
-	; HL = address of string memory variable
-	; DE = address of 2n string. It just copies DE into (HL)
-	; 	freeing (HL) previously.
+#line 92 "arch/zx48k/local_str_array2.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+; vim:ts=4:et:sw=4
+	; Stores value of current string pointed by DE register into address pointed by HL
+	; Returns DE = Address pointer  (&a$)
+	; Returns HL = HL               (b$ => might be needed later to free it from the heap)
+	;
+	; e.g. => HL = _variableName    (DIM _variableName$)
+	;         DE = Address into the HEAP
+	;
+	; This function will resize (REALLOC) the space pointed by HL
+	; before copying the content of b$ into a$
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/realloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_REALLOC
+	;  Reallocates a block of memory in the heap.
+	;
+	; Parameters
+	;  HL = Pointer to the original block
+	;  BC = New Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	;
+; Notes:
+	;  If BC = 0, the block is freed, otherwise
+	;  the content of the original block is copied to the new one, and
+	;  the new size is adjusted. If BC < original length, the content
+	;  will be truncated. Otherwise, extra block content might contain
+	;  memory garbage.
+	;
+	; ---------------------------------------------------------------------
 	    push namespace core
-__PISTORE_STR2: ; Indirect store temporary string at (IX + BC)
+__REALLOC:    ; Reallocates block pointed by HL, with new length BC
+	    PROC
+	    LOCAL __REALLOC_END
+	    ld a, h
+	    or l
+	    jp z, __MEM_ALLOC    ; If HL == NULL, just do a malloc
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)    ; DE = First 2 bytes of HL block
+	    push hl
+	    exx
+	    pop de
+	    inc de        ; DE' <- HL + 2
+	    exx            ; DE' <- HL (Saves current pointer into DE')
+	    dec hl        ; HL = Block start
+	    push de
+	    push bc
+	    call __MEM_FREE        ; Frees current block
+	    pop bc
+	    push bc
+	    call __MEM_ALLOC    ; Gets a new block of length BC
+	    pop bc
+	    pop de
+	    ld a, h
+	    or l
+	    ret z        ; Return if HL == NULL (No memory)
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl        ; Recovers first 2 bytes in HL
+	    dec bc
+	    dec bc        ; BC = BC - 2 (Two bytes copied)
+	    ld a, b
+	    or c
+	    jp z, __REALLOC_END        ; Ret if nothing to copy (BC == 0)
+	    exx
+	    push de
+	    exx
+	    pop de        ; DE <- DE' ; Start of remaining block
+	    push hl        ; Saves current Block + 2 start
+    ex de, hl    ; Exchanges them: DE is destiny block
+	    ldir        ; Copies BC Bytes
+	    pop hl        ; Recovers Block + 2 start
+__REALLOC_END:
+	    dec hl        ; Set HL
+	    dec hl        ; To begin of block
+	    ret
+	    ENDP
+	    pop namespace
+#line 2 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+	; String library
+	    push namespace core
+__STRASSIGN: ; Performs a$ = b$ (HL = address of a$; DE = Address of b$)
+	    PROC
+	    LOCAL __STRREALLOC
+	    LOCAL __STRCONTINUE
+	    LOCAL __B_IS_NULL
+	    LOCAL __NOTHING_TO_COPY
+	    ld b, d
+	    ld c, e
+	    ld a, b
+	    or c
+	    jr z, __B_IS_NULL
+	    ex de, hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl		; BC = LEN(b$)
+	    ex de, hl	; DE = &b$
+__B_IS_NULL:		; Jumps here if B$ pointer is NULL
+	    inc bc
+	    inc bc		; BC = BC + 2  ; (LEN(b$) + 2 bytes for storing length)
+	    push de
+	    push hl
+	    ld a, h
+	    or l
+	    jr z, __STRREALLOC
+	    dec hl
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)	; DE = MEMBLOCKSIZE(a$)
+	    dec de
+	    dec de		; DE = DE - 2  ; (Membloksize takes 2 bytes for memblock length)
+	    ld h, b
+	    ld l, c		; HL = LEN(b$) + 2  => Minimum block size required
+	    ex de, hl	; Now HL = BLOCKSIZE(a$), DE = LEN(b$) + 2
+	    or a		; Prepare to subtract BLOCKSIZE(a$) - LEN(b$)
+	    sbc hl, de  ; Carry if len(b$) > Blocklen(a$)
+	    jr c, __STRREALLOC ; No need to realloc
+	    ; Need to reallocate at least to len(b$) + 2
+	    ex de, hl	; DE = Remaining bytes in a$ mem block.
+	    ld hl, 4
+	    sbc hl, de  ; if remaining bytes < 4 we can continue
+	    jr nc,__STRCONTINUE ; Otherwise, we realloc, to free some bytes
+__STRREALLOC:
+	    pop hl
+	    call __REALLOC	; Returns in HL a new pointer with BC bytes allocated
+	    push hl
+__STRCONTINUE:	;   Pops hl and de SWAPPED
+	    pop de	;	DE = &a$
+	    pop hl	; 	HL = &b$
+	    ld a, d		; Return if not enough memory for new length
+	    or e
+	    ret z		; Return if DE == NULL (0)
+__STRCPY:	; Copies string pointed by HL into string pointed by DE
+	    ; Returns DE as HL (new pointer)
+	    ld a, h
+	    or l
+	    jr z, __NOTHING_TO_COPY
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl
+	    inc bc
+	    inc bc
+	    push de
+	    ldir
+	    pop hl
+	    ret
+__NOTHING_TO_COPY:
+	    ex de, hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    dec hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 14 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+	    push namespace core
+__PISTORE_STR:          ; Indirect assignment at (IX + BC)
 	    push ix
 	    pop hl
 	    add hl, bc
-__ISTORE_STR2:
-	    ld c, (hl)  ; Dereferences HL
+__ISTORE_STR:           ; Indirect assignment, hl point to a pointer to a pointer to the heap!
+	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string variable address)
-__STORE_STR2:
-	    push hl
+	    ld l, c             ; HL = (HL)
+__STORE_STR:
+	    push de             ; Pointer to b$
+	    push hl             ; Pointer to a$
 	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string address)
-	    push de
-	    call __MEM_FREE
-	    pop de
-	    pop hl
+	    ld l, c             ; HL = (HL)
+	    call __STRASSIGN    ; HL (a$) = DE (b$); HL changed to a new dynamic memory allocation
+	    ex de, hl           ; DE = new address of a$
+	    pop hl              ; Recover variable memory address pointer
 	    ld (hl), e
 	    inc hl
-	    ld (hl), d
-	    dec hl		; HL points to mem address variable. This might be useful in the future.
+	    ld (hl), d          ; Stores a$ ptr into element ptr
+	    pop hl              ; Returns ptr to b$ in HL (Caller might needed to free it from memory)
 	    ret
 	    pop namespace
 #line 94 "arch/zx48k/local_str_array2.bas"
diff --git a/tests/functional/arch/zx48k/local_str_array3.asm b/tests/functional/arch/zx48k/local_str_array3.asm
index 3dd129d4d..e783bd8e8 100644
--- a/tests/functional/arch/zx48k/local_str_array3.asm
+++ b/tests/functional/arch/zx48k/local_str_array3.asm
@@ -70,8 +70,8 @@ _test:
 	ld de, -8
 	add hl, de
 	call .core.__ARRAY
-	pop de
-	call .core.__STORE_STR2
+	ld de, .LABEL.__LABEL5
+	call .core.__STORE_STR
 .LABEL.__LABEL4:
 	ld l, (ix-2)
 	ld h, (ix-1)
@@ -290,7 +290,7 @@ ARRAY_SIZE_LOOP:
 	    pop namespace
 #line 108 "arch/zx48k/local_str_array3.bas"
 #line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -301,7 +301,7 @@ ARRAY_SIZE_LOOP:
 	; closed source programs).
 	;
 	; Please read the MIT license on the internet
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -395,8 +395,8 @@ __STOP:
 	    ld (ERR_NR), a
 	    ret
 	    pop namespace
-#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/heapinit.asm"
+#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/heapinit.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -503,7 +503,7 @@ __MEM_INIT2:
 	    ret
 	    ENDP
 	    pop namespace
-#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_ALLOC
 	;  Allocates a block of memory in the heap.
@@ -534,9 +534,9 @@ __MEM_START:
 __MEM_LOOP:  ; Loads lengh at (HL, HL+). If Lenght >= BC, jump to __MEM_DONE
 	    ld a, h ;  HL = NULL (No memory available?)
 	    or l
-#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ret z ; NULL
-#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ; HL = Pointer to Free block
 	    ld e, (hl)
 	    inc hl
@@ -601,7 +601,7 @@ __MEM_SUBTRACT:
 	    ret
 	    ENDP
 	    pop namespace
-#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_CALLOC
 	;  Allocates a block of memory in the heap, and clears it filling it
@@ -706,7 +706,7 @@ __ALLOC_INITIALIZED_LOCAL_ARRAY:
 	; This routine is in charge of freeing an array of strings from memory
 	; HL = Pointer to start of array in memory
 	; Top of the stack = Number of elements of the array
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/free.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/free.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -944,38 +944,253 @@ __LOADSTR:		; __FASTCALL__ entry
 	    pop hl	; Recovers destiny in hl as result
 	    ret
 	    pop namespace
-#line 112 "arch/zx48k/local_str_array3.bas"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr2.asm"
-	; Similar to __STORE_STR, but this one is called when
-	; the value of B$ if already duplicated onto the stack.
-	; So we needn't call STRASSING to create a duplication
-	; HL = address of string memory variable
-	; DE = address of 2n string. It just copies DE into (HL)
-	; 	freeing (HL) previously.
+#line 111 "arch/zx48k/local_str_array3.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+; vim:ts=4:et:sw=4
+	; Stores value of current string pointed by DE register into address pointed by HL
+	; Returns DE = Address pointer  (&a$)
+	; Returns HL = HL               (b$ => might be needed later to free it from the heap)
+	;
+	; e.g. => HL = _variableName    (DIM _variableName$)
+	;         DE = Address into the HEAP
+	;
+	; This function will resize (REALLOC) the space pointed by HL
+	; before copying the content of b$ into a$
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/realloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_REALLOC
+	;  Reallocates a block of memory in the heap.
+	;
+	; Parameters
+	;  HL = Pointer to the original block
+	;  BC = New Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	;
+; Notes:
+	;  If BC = 0, the block is freed, otherwise
+	;  the content of the original block is copied to the new one, and
+	;  the new size is adjusted. If BC < original length, the content
+	;  will be truncated. Otherwise, extra block content might contain
+	;  memory garbage.
+	;
+	; ---------------------------------------------------------------------
+	    push namespace core
+__REALLOC:    ; Reallocates block pointed by HL, with new length BC
+	    PROC
+	    LOCAL __REALLOC_END
+	    ld a, h
+	    or l
+	    jp z, __MEM_ALLOC    ; If HL == NULL, just do a malloc
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)    ; DE = First 2 bytes of HL block
+	    push hl
+	    exx
+	    pop de
+	    inc de        ; DE' <- HL + 2
+	    exx            ; DE' <- HL (Saves current pointer into DE')
+	    dec hl        ; HL = Block start
+	    push de
+	    push bc
+	    call __MEM_FREE        ; Frees current block
+	    pop bc
+	    push bc
+	    call __MEM_ALLOC    ; Gets a new block of length BC
+	    pop bc
+	    pop de
+	    ld a, h
+	    or l
+	    ret z        ; Return if HL == NULL (No memory)
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl        ; Recovers first 2 bytes in HL
+	    dec bc
+	    dec bc        ; BC = BC - 2 (Two bytes copied)
+	    ld a, b
+	    or c
+	    jp z, __REALLOC_END        ; Ret if nothing to copy (BC == 0)
+	    exx
+	    push de
+	    exx
+	    pop de        ; DE <- DE' ; Start of remaining block
+	    push hl        ; Saves current Block + 2 start
+    ex de, hl    ; Exchanges them: DE is destiny block
+	    ldir        ; Copies BC Bytes
+	    pop hl        ; Recovers Block + 2 start
+__REALLOC_END:
+	    dec hl        ; Set HL
+	    dec hl        ; To begin of block
+	    ret
+	    ENDP
+	    pop namespace
+#line 2 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+	; String library
+	    push namespace core
+__STRASSIGN: ; Performs a$ = b$ (HL = address of a$; DE = Address of b$)
+	    PROC
+	    LOCAL __STRREALLOC
+	    LOCAL __STRCONTINUE
+	    LOCAL __B_IS_NULL
+	    LOCAL __NOTHING_TO_COPY
+	    ld b, d
+	    ld c, e
+	    ld a, b
+	    or c
+	    jr z, __B_IS_NULL
+	    ex de, hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl		; BC = LEN(b$)
+	    ex de, hl	; DE = &b$
+__B_IS_NULL:		; Jumps here if B$ pointer is NULL
+	    inc bc
+	    inc bc		; BC = BC + 2  ; (LEN(b$) + 2 bytes for storing length)
+	    push de
+	    push hl
+	    ld a, h
+	    or l
+	    jr z, __STRREALLOC
+	    dec hl
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)	; DE = MEMBLOCKSIZE(a$)
+	    dec de
+	    dec de		; DE = DE - 2  ; (Membloksize takes 2 bytes for memblock length)
+	    ld h, b
+	    ld l, c		; HL = LEN(b$) + 2  => Minimum block size required
+	    ex de, hl	; Now HL = BLOCKSIZE(a$), DE = LEN(b$) + 2
+	    or a		; Prepare to subtract BLOCKSIZE(a$) - LEN(b$)
+	    sbc hl, de  ; Carry if len(b$) > Blocklen(a$)
+	    jr c, __STRREALLOC ; No need to realloc
+	    ; Need to reallocate at least to len(b$) + 2
+	    ex de, hl	; DE = Remaining bytes in a$ mem block.
+	    ld hl, 4
+	    sbc hl, de  ; if remaining bytes < 4 we can continue
+	    jr nc,__STRCONTINUE ; Otherwise, we realloc, to free some bytes
+__STRREALLOC:
+	    pop hl
+	    call __REALLOC	; Returns in HL a new pointer with BC bytes allocated
+	    push hl
+__STRCONTINUE:	;   Pops hl and de SWAPPED
+	    pop de	;	DE = &a$
+	    pop hl	; 	HL = &b$
+	    ld a, d		; Return if not enough memory for new length
+	    or e
+	    ret z		; Return if DE == NULL (0)
+__STRCPY:	; Copies string pointed by HL into string pointed by DE
+	    ; Returns DE as HL (new pointer)
+	    ld a, h
+	    or l
+	    jr z, __NOTHING_TO_COPY
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl
+	    inc bc
+	    inc bc
+	    push de
+	    ldir
+	    pop hl
+	    ret
+__NOTHING_TO_COPY:
+	    ex de, hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    dec hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 14 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
 	    push namespace core
-__PISTORE_STR2: ; Indirect store temporary string at (IX + BC)
+__PISTORE_STR:          ; Indirect assignment at (IX + BC)
 	    push ix
 	    pop hl
 	    add hl, bc
-__ISTORE_STR2:
-	    ld c, (hl)  ; Dereferences HL
+__ISTORE_STR:           ; Indirect assignment, hl point to a pointer to a pointer to the heap!
+	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string variable address)
-__STORE_STR2:
-	    push hl
+	    ld l, c             ; HL = (HL)
+__STORE_STR:
+	    push de             ; Pointer to b$
+	    push hl             ; Pointer to a$
 	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string address)
-	    push de
-	    call __MEM_FREE
-	    pop de
-	    pop hl
+	    ld l, c             ; HL = (HL)
+	    call __STRASSIGN    ; HL (a$) = DE (b$); HL changed to a new dynamic memory allocation
+	    ex de, hl           ; DE = new address of a$
+	    pop hl              ; Recover variable memory address pointer
 	    ld (hl), e
 	    inc hl
-	    ld (hl), d
-	    dec hl		; HL points to mem address variable. This might be useful in the future.
+	    ld (hl), d          ; Stores a$ ptr into element ptr
+	    pop hl              ; Returns ptr to b$ in HL (Caller might needed to free it from memory)
 	    ret
 	    pop namespace
 #line 113 "arch/zx48k/local_str_array3.bas"
diff --git a/tests/functional/arch/zx48k/local_str_array4.asm b/tests/functional/arch/zx48k/local_str_array4.asm
new file mode 100644
index 000000000..0bac348ed
--- /dev/null
+++ b/tests/functional/arch/zx48k/local_str_array4.asm
@@ -0,0 +1,1025 @@
+	org 32768
+.core.__START_PROGRAM:
+	di
+	push ix
+	push iy
+	exx
+	push hl
+	exx
+	ld (.core.__CALL_BACK__), sp
+	ei
+	call .core.__MEM_INIT
+	jp .core.__MAIN_PROGRAM__
+.core.__CALL_BACK__:
+	DEFW 0
+.core.ZXBASIC_USER_DATA:
+	; Defines HEAP SIZE
+.core.ZXBASIC_HEAP_SIZE EQU 4768
+.core.ZXBASIC_MEM_HEAP:
+	DEFS 4768
+	; Defines USER DATA Length in bytes
+.core.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_END - .core.ZXBASIC_USER_DATA
+	.core.__LABEL__.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_LEN
+	.core.__LABEL__.ZXBASIC_USER_DATA EQU .core.ZXBASIC_USER_DATA
+_index:
+	DEFB 00, 00
+_TABLENAMES:
+	DEFW .LABEL.__LABEL1
+_TABLENAMES.__DATA__.__PTR__:
+	DEFW _TABLENAMES.__DATA__
+	DEFW 0
+	DEFW 0
+_TABLENAMES.__DATA__:
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+	DEFB 00h
+.LABEL.__LABEL1:
+	DEFW 0000h
+	DEFB 02h
+.core.ZXBASIC_USER_DATA_END:
+.core.__MAIN_PROGRAM__:
+	ld hl, _TABLENAMES
+	push hl
+	ld hl, .LABEL.__LABEL0
+	call .core.__LOADSTR
+	push hl
+	call _Test
+	ld hl, 0
+	ld b, h
+	ld c, l
+.core.__END_PROGRAM:
+	di
+	ld hl, (.core.__CALL_BACK__)
+	ld sp, hl
+	exx
+	pop hl
+	exx
+	pop iy
+	pop ix
+	ei
+	ret
+_Test:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld l, (ix+4)
+	ld h, (ix+5)
+	push hl
+	ld hl, (_index)
+	push hl
+	push ix
+	pop hl
+	ld de, 6
+	add hl, de
+	call .core.__ARRAY_PTR
+	pop de
+	call .core.__STORE_STR
+_Test__leave:
+	ex af, af'
+	exx
+	ld l, (ix+4)
+	ld h, (ix+5)
+	call .core.__MEM_FREE
+	ex af, af'
+	exx
+	ld sp, ix
+	pop ix
+	exx
+	pop hl
+	pop bc
+	ex (sp), hl
+	exx
+	ret
+.LABEL.__LABEL0:
+	DEFW 0003h
+	DEFB 4Fh
+	DEFB 55h
+	DEFB 50h
+	;; --- end of user code ---
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	; -------------------------------------------------------------------
+	; Simple array Index routine
+	; Number of total indexes dimensions - 1 at beginning of memory
+	; HL = Start of array memory (First two bytes contains N-1 dimensions)
+	; Dimension values on the stack, (top of the stack, highest dimension)
+	; E.g. A(2, 4) -> PUSH <4>; PUSH <2>
+	; For any array of N dimension A(aN-1, ..., a1, a0)
+	; and dimensions D[bN-1, ..., b1, b0], the offset is calculated as
+	; O = [a0 + b0 * (a1 + b1 * (a2 + ... bN-2(aN-1)))]
+; What I will do here is to calculate the following sequence:
+	; ((aN-1 * bN-2) + aN-2) * bN-3 + ...
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	;; Performs a faster multiply for little 16bit numbs
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/arith/mul16.asm"
+	    push namespace core
+__MUL16:	; Mutiplies HL with the last value stored into de stack
+	    ; Works for both signed and unsigned
+	    PROC
+	    LOCAL __MUL16LOOP
+	    LOCAL __MUL16NOADD
+	    ex de, hl
+	    pop hl		; Return address
+	    ex (sp), hl ; CALLEE caller convention
+__MUL16_FAST:
+	    ld b, 16
+	    ld a, h
+	    ld c, l
+	    ld hl, 0
+__MUL16LOOP:
+	    add hl, hl  ; hl << 1
+	    sla c
+	    rla         ; a,c << 1
+	    jp nc, __MUL16NOADD
+	    add hl, de
+__MUL16NOADD:
+	    djnz __MUL16LOOP
+	    ret	; Result in hl (16 lower bits)
+	    ENDP
+	    pop namespace
+#line 3 "/zxbasic/src/lib/arch/zx48k/runtime/arith/fmul16.asm"
+	    push namespace core
+__FMUL16:
+	    xor a
+	    or h
+	    jp nz, __MUL16_FAST
+	    or l
+	    ret z
+	    cp 33
+	    jp nc, __MUL16_FAST
+	    ld b, l
+	    ld l, h  ; HL = 0
+1:
+	    add hl, de
+	    djnz 1b
+	    ret
+	    pop namespace
+#line 20 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+#line 24 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    push namespace core
+__ARRAY_PTR:   ;; computes an array offset from a pointer
+	    ld c, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, c    ;; HL <-- [HL]
+__ARRAY:
+	    PROC
+	    LOCAL LOOP
+	    LOCAL ARRAY_END
+	    LOCAL TMP_ARR_PTR            ; Ptr to Array DATA region. Stored temporarily
+	    LOCAL LBOUND_PTR, UBOUND_PTR ; LBound and UBound PTR indexes
+	    LOCAL RET_ADDR               ; Contains the return address popped from the stack
+	LBOUND_PTR EQU 23698           ; Uses MEMBOT as a temporary variable
+	UBOUND_PTR EQU LBOUND_PTR + 2  ; Next 2 bytes for UBOUND PTR
+	RET_ADDR EQU UBOUND_PTR + 2    ; Next 2 bytes for RET_ADDR
+	TMP_ARR_PTR EQU RET_ADDR + 2   ; Next 2 bytes for TMP_ARR_PTR
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    inc hl      ; DE <-- PTR to Dim sizes table
+	    ld (TMP_ARR_PTR), hl  ; HL = Array __DATA__.__PTR__
+	    inc hl
+	    inc hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)  ; BC <-- Array __LBOUND__ PTR
+	    ld (LBOUND_PTR), bc  ; Store it for later
+#line 66 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl   ; HL <-- PTR to Dim sizes table, DE <-- dummy
+	    ex (sp), hl	; Return address in HL, PTR Dim sizes table onto Stack
+	    ld (RET_ADDR), hl ; Stores it for later
+	    exx
+	    pop hl		; Will use H'L' as the pointer to Dim sizes table
+	    ld c, (hl)	; Loads Number of dimensions from (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl		; Ready
+	    exx
+	    ld hl, 0	; HL = Element Offset "accumulator"
+LOOP:
+	    ex de, hl   ; DE = Element Offset
+	    ld hl, (LBOUND_PTR)
+	    ld a, h
+	    or l
+	    ld b, h
+	    ld c, l
+	    jr z, 1f
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl
+	    ld (LBOUND_PTR), hl
+1:
+	    pop hl      ; Get next index (Ai) from the stack
+	    sbc hl, bc  ; Subtract LBOUND
+#line 116 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    add hl, de	; Adds current index
+	    exx			; Checks if B'C' = 0
+	    ld a, b		; Which means we must exit (last element is not multiplied by anything)
+	    or c
+	    jr z, ARRAY_END		; if B'Ci == 0 we are done
+	    dec bc				; Decrements loop counter
+	    ld e, (hl)			; Loads next dimension size into D'E'
+	    inc hl
+	    ld d, (hl)
+	    inc hl
+	    push de
+	    exx
+	    pop de				; DE = Max bound Number (i-th dimension)
+	    call __FMUL16        ; HL <= HL * DE mod 65536
+	    jp LOOP
+ARRAY_END:
+	    ld a, (hl)
+	    exx
+#line 146 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    LOCAL ARRAY_SIZE_LOOP
+	    ex de, hl
+	    ld hl, 0
+	    ld b, a
+ARRAY_SIZE_LOOP:
+	    add hl, de
+	    djnz ARRAY_SIZE_LOOP
+#line 156 "/zxbasic/src/lib/arch/zx48k/runtime/array/array.asm"
+	    ex de, hl
+	    ld hl, (TMP_ARR_PTR)
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a
+	    add hl, de  ; Adds element start
+	    ld de, (RET_ADDR)
+	    push de
+	    ret
+	    ENDP
+	    pop namespace
+#line 60 "arch/zx48k/local_str_array4.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/loadstr.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the MIT license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the MIT license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be freed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/error.asm"
+	; Simple error control routines
+; vim:ts=4:et:
+	    push namespace core
+	ERR_NR    EQU    23610    ; Error code system variable
+	; Error code definitions (as in ZX spectrum manual)
+; Set error code with:
+	;    ld a, ERROR_CODE
+	;    ld (ERR_NR), a
+	ERROR_Ok                EQU    -1
+	ERROR_SubscriptWrong    EQU     2
+	ERROR_OutOfMemory       EQU     3
+	ERROR_OutOfScreen       EQU     4
+	ERROR_NumberTooBig      EQU     5
+	ERROR_InvalidArg        EQU     9
+	ERROR_IntOutOfRange     EQU    10
+	ERROR_NonsenseInBasic   EQU    11
+	ERROR_InvalidFileName   EQU    14
+	ERROR_InvalidColour     EQU    19
+	ERROR_BreakIntoProgram  EQU    20
+	ERROR_TapeLoadingErr    EQU    26
+	; Raises error using RST #8
+__ERROR:
+	    ld (__ERROR_CODE), a
+	    rst 8
+__ERROR_CODE:
+	    nop
+	    ret
+	; Sets the error system variable, but keeps running.
+	; Usually this instruction if followed by the END intermediate instruction.
+__STOP:
+	    ld (ERR_NR), a
+	    ret
+	    pop namespace
+#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/heapinit.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	;  __MEM_INIT must be called to initalize this library with the
+	; standard parameters
+	; ---------------------------------------------------------------------
+	    push namespace core
+__MEM_INIT: ; Initializes the library using (RAMTOP) as start, and
+	    ld hl, ZXBASIC_MEM_HEAP  ; Change this with other address of heap start
+	    ld de, ZXBASIC_HEAP_SIZE ; Change this with your size
+	; ---------------------------------------------------------------------
+	;  __MEM_INIT2 initalizes this library
+; Parameters:
+;   HL : Memory address of 1st byte of the memory heap
+;   DE : Length in bytes of the Memory Heap
+	; ---------------------------------------------------------------------
+__MEM_INIT2:
+	    ; HL as TOP
+	    PROC
+	    dec de
+	    dec de
+	    dec de
+	    dec de        ; DE = length - 4; HL = start
+	    ; This is done, because we require 4 bytes for the empty dummy-header block
+	    xor a
+	    ld (hl), a
+	    inc hl
+    ld (hl), a ; First "free" block is a header: size=0, Pointer=&(Block) + 4
+	    inc hl
+	    ld b, h
+	    ld c, l
+	    inc bc
+	    inc bc      ; BC = starts of next block
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b
+	    inc hl      ; Pointer to next block
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl      ; Block size (should be length - 4 at start); This block contains all the available memory
+	    ld (hl), a ; NULL (0000h) ; No more blocks (a list with a single block)
+	    inc hl
+	    ld (hl), a
+	    ld a, 201
+	    ld (__MEM_INIT), a; "Pokes" with a RET so ensure this routine is not called again
+	    ret
+	    ENDP
+	    pop namespace
+#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	; ---------------------------------------------------------------------
+	; MEM_ALLOC
+	;  Allocates a block of memory in the heap.
+	;
+	; Parameters
+	;  BC = Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	; ---------------------------------------------------------------------
+	    push namespace core
+MEM_ALLOC:
+__MEM_ALLOC: ; Returns the 1st free block found of the given length (in BC)
+	    PROC
+	    LOCAL __MEM_LOOP
+	    LOCAL __MEM_DONE
+	    LOCAL __MEM_SUBTRACT
+	    LOCAL __MEM_START
+	    LOCAL TEMP, TEMP0
+	TEMP EQU TEMP0 + 1
+	    ld hl, 0
+	    ld (TEMP), hl
+__MEM_START:
+	    ld hl, ZXBASIC_MEM_HEAP  ; This label point to the heap start
+	    inc bc
+	    inc bc  ; BC = BC + 2 ; block size needs 2 extra bytes for hidden pointer
+__MEM_LOOP:  ; Loads lengh at (HL, HL+). If Lenght >= BC, jump to __MEM_DONE
+	    ld a, h ;  HL = NULL (No memory available?)
+	    or l
+#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	    ret z ; NULL
+#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+	    ; HL = Pointer to Free block
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    inc hl          ; DE = Block Length
+	    push hl         ; HL = *pointer to -> next block
+	    ex de, hl
+	    or a            ; CF = 0
+	    sbc hl, bc      ; FREE >= BC (Length)  (HL = BlockLength - Length)
+	    jp nc, __MEM_DONE
+	    pop hl
+	    ld (TEMP), hl
+	    ex de, hl
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)
+	    ex de, hl
+	    jp __MEM_LOOP
+__MEM_DONE:  ; A free block has been found.
+	    ; Check if at least 4 bytes remains free (HL >= 4)
+	    push hl
+	    exx  ; exx to preserve bc
+	    pop hl
+	    ld bc, 4
+	    or a
+	    sbc hl, bc
+	    exx
+	    jp nc, __MEM_SUBTRACT
+	    ; At this point...
+	    ; less than 4 bytes remains free. So we return this block entirely
+	    ; We must link the previous block with the next to this one
+	    ; (DE) => Pointer to next block
+	    ; (TEMP) => &(previous->next)
+	    pop hl     ; Discard current block pointer
+	    push de
+	    ex de, hl  ; DE = Previous block pointer; (HL) = Next block pointer
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a    ; HL = (HL)
+	    ex de, hl  ; HL = Previous block pointer; DE = Next block pointer
+TEMP0:
+	    ld hl, 0   ; Pre-previous block pointer
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d ; LINKED
+	    pop hl ; Returning block.
+	    ret
+__MEM_SUBTRACT:
+	    ; At this point we have to store HL value (Length - BC) into (DE - 2)
+	    ex de, hl
+	    dec hl
+	    ld (hl), d
+	    dec hl
+	    ld (hl), e ; Store new block length
+	    add hl, de ; New length + DE => free-block start
+	    pop de     ; Remove previous HL off the stack
+	    ld (hl), c ; Store length on its 1st word
+	    inc hl
+	    ld (hl), b
+	    inc hl     ; Return hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 2 "/zxbasic/src/lib/arch/zx48k/runtime/loadstr.asm"
+	; Loads a string (ptr) from HL
+	; and duplicates it on dynamic memory again
+	; Finally, it returns result pointer in HL
+	    push namespace core
+__ILOADSTR:		; This is the indirect pointer entry HL = (HL)
+	    ld a, h
+	    or l
+	    ret z
+	    ld a, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, a
+__LOADSTR:		; __FASTCALL__ entry
+	    ld a, h
+	    or l
+	    ret z	; Return if NULL
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl  ; BC = LEN(a$)
+	    inc bc
+	    inc bc	; BC = LEN(a$) + 2 (two bytes for length)
+	    push hl
+	    push bc
+	    call __MEM_ALLOC
+	    pop bc  ; Recover length
+	    pop de  ; Recover origin
+	    ld a, h
+	    or l
+	    ret z	; Return if NULL (No memory)
+	    ex de, hl ; ldir takes HL as source, DE as destiny, so SWAP HL,DE
+	    push de	; Saves destiny start
+	    ldir	; Copies string (length number included)
+	    pop hl	; Recovers destiny in hl as result
+	    ret
+	    pop namespace
+#line 61 "arch/zx48k/local_str_array4.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/free.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_FREE
+	;  Frees a block of memory
+	;
+; Parameters:
+	;  HL = Pointer to the block to be freed. If HL is NULL (0) nothing
+	;  is done
+	; ---------------------------------------------------------------------
+	    push namespace core
+MEM_FREE:
+__MEM_FREE: ; Frees the block pointed by HL
+	    ; HL DE BC & AF modified
+	    PROC
+	    LOCAL __MEM_LOOP2
+	    LOCAL __MEM_LINK_PREV
+	    LOCAL __MEM_JOIN_TEST
+	    LOCAL __MEM_BLOCK_JOIN
+	    ld a, h
+	    or l
+	    ret z       ; Return if NULL pointer
+	    dec hl
+	    dec hl
+	    ld b, h
+	    ld c, l    ; BC = Block pointer
+	    ld hl, ZXBASIC_MEM_HEAP  ; This label point to the heap start
+__MEM_LOOP2:
+	    inc hl
+	    inc hl     ; Next block ptr
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl) ; Block next ptr
+	    ex de, hl  ; DE = &(block->next); HL = block->next
+	    ld a, h    ; HL == NULL?
+	    or l
+	    jp z, __MEM_LINK_PREV; if so, link with previous
+	    or a       ; Clear carry flag
+	    sbc hl, bc ; Carry if BC > HL => This block if before
+	    add hl, bc ; Restores HL, preserving Carry flag
+	    jp c, __MEM_LOOP2 ; This block is before. Keep searching PASS the block
+	;------ At this point current HL is PAST BC, so we must link (DE) with BC, and HL in BC->next
+__MEM_LINK_PREV:    ; Link (DE) with BC, and BC->next with HL
+	    ex de, hl
+	    push hl
+	    dec hl
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b ; (DE) <- BC
+	    ld h, b    ; HL <- BC (Free block ptr)
+	    ld l, c
+	    inc hl     ; Skip block length (2 bytes)
+	    inc hl
+	    ld (hl), e ; Block->next = DE
+	    inc hl
+	    ld (hl), d
+	    ; --- LINKED ; HL = &(BC->next) + 2
+	    call __MEM_JOIN_TEST
+	    pop hl
+__MEM_JOIN_TEST:   ; Checks for fragmented contiguous blocks and joins them
+	    ; hl = Ptr to current block + 2
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)
+	    dec hl
+	    ld b, (hl) ; Loads block length into BC
+	    dec hl
+	    ld c, (hl) ;
+	    push hl    ; Saves it for later
+	    add hl, bc ; Adds its length. If HL == DE now, it must be joined
+	    or a
+	    sbc hl, de ; If Z, then HL == DE => We must join
+	    pop hl
+	    ret nz
+__MEM_BLOCK_JOIN:  ; Joins current block (pointed by HL) with next one (pointed by DE). HL->length already in BC
+	    push hl    ; Saves it for later
+	    ex de, hl
+	    ld e, (hl) ; DE -> block->next->length
+	    inc hl
+	    ld d, (hl)
+	    inc hl
+	    ex de, hl  ; DE = &(block->next)
+	    add hl, bc ; HL = Total Length
+	    ld b, h
+	    ld c, l    ; BC = Total Length
+	    ex de, hl
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl) ; DE = block->next
+	    pop hl     ; Recovers Pointer to block
+	    ld (hl), c
+	    inc hl
+	    ld (hl), b ; Length Saved
+	    inc hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d ; Next saved
+	    ret
+	    ENDP
+	    pop namespace
+#line 62 "arch/zx48k/local_str_array4.bas"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+; vim:ts=4:et:sw=4
+	; Stores value of current string pointed by DE register into address pointed by HL
+	; Returns DE = Address pointer  (&a$)
+	; Returns HL = HL               (b$ => might be needed later to free it from the heap)
+	;
+	; e.g. => HL = _variableName    (DIM _variableName$)
+	;         DE = Address into the HEAP
+	;
+	; This function will resize (REALLOC) the space pointed by HL
+	; before copying the content of b$ into a$
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/realloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_REALLOC
+	;  Reallocates a block of memory in the heap.
+	;
+	; Parameters
+	;  HL = Pointer to the original block
+	;  BC = New Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	;
+; Notes:
+	;  If BC = 0, the block is freed, otherwise
+	;  the content of the original block is copied to the new one, and
+	;  the new size is adjusted. If BC < original length, the content
+	;  will be truncated. Otherwise, extra block content might contain
+	;  memory garbage.
+	;
+	; ---------------------------------------------------------------------
+	    push namespace core
+__REALLOC:    ; Reallocates block pointed by HL, with new length BC
+	    PROC
+	    LOCAL __REALLOC_END
+	    ld a, h
+	    or l
+	    jp z, __MEM_ALLOC    ; If HL == NULL, just do a malloc
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)    ; DE = First 2 bytes of HL block
+	    push hl
+	    exx
+	    pop de
+	    inc de        ; DE' <- HL + 2
+	    exx            ; DE' <- HL (Saves current pointer into DE')
+	    dec hl        ; HL = Block start
+	    push de
+	    push bc
+	    call __MEM_FREE        ; Frees current block
+	    pop bc
+	    push bc
+	    call __MEM_ALLOC    ; Gets a new block of length BC
+	    pop bc
+	    pop de
+	    ld a, h
+	    or l
+	    ret z        ; Return if HL == NULL (No memory)
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl        ; Recovers first 2 bytes in HL
+	    dec bc
+	    dec bc        ; BC = BC - 2 (Two bytes copied)
+	    ld a, b
+	    or c
+	    jp z, __REALLOC_END        ; Ret if nothing to copy (BC == 0)
+	    exx
+	    push de
+	    exx
+	    pop de        ; DE <- DE' ; Start of remaining block
+	    push hl        ; Saves current Block + 2 start
+    ex de, hl    ; Exchanges them: DE is destiny block
+	    ldir        ; Copies BC Bytes
+	    pop hl        ; Recovers Block + 2 start
+__REALLOC_END:
+	    dec hl        ; Set HL
+	    dec hl        ; To begin of block
+	    ret
+	    ENDP
+	    pop namespace
+#line 2 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+	; String library
+	    push namespace core
+__STRASSIGN: ; Performs a$ = b$ (HL = address of a$; DE = Address of b$)
+	    PROC
+	    LOCAL __STRREALLOC
+	    LOCAL __STRCONTINUE
+	    LOCAL __B_IS_NULL
+	    LOCAL __NOTHING_TO_COPY
+	    ld b, d
+	    ld c, e
+	    ld a, b
+	    or c
+	    jr z, __B_IS_NULL
+	    ex de, hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl		; BC = LEN(b$)
+	    ex de, hl	; DE = &b$
+__B_IS_NULL:		; Jumps here if B$ pointer is NULL
+	    inc bc
+	    inc bc		; BC = BC + 2  ; (LEN(b$) + 2 bytes for storing length)
+	    push de
+	    push hl
+	    ld a, h
+	    or l
+	    jr z, __STRREALLOC
+	    dec hl
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)	; DE = MEMBLOCKSIZE(a$)
+	    dec de
+	    dec de		; DE = DE - 2  ; (Membloksize takes 2 bytes for memblock length)
+	    ld h, b
+	    ld l, c		; HL = LEN(b$) + 2  => Minimum block size required
+	    ex de, hl	; Now HL = BLOCKSIZE(a$), DE = LEN(b$) + 2
+	    or a		; Prepare to subtract BLOCKSIZE(a$) - LEN(b$)
+	    sbc hl, de  ; Carry if len(b$) > Blocklen(a$)
+	    jr c, __STRREALLOC ; No need to realloc
+	    ; Need to reallocate at least to len(b$) + 2
+	    ex de, hl	; DE = Remaining bytes in a$ mem block.
+	    ld hl, 4
+	    sbc hl, de  ; if remaining bytes < 4 we can continue
+	    jr nc,__STRCONTINUE ; Otherwise, we realloc, to free some bytes
+__STRREALLOC:
+	    pop hl
+	    call __REALLOC	; Returns in HL a new pointer with BC bytes allocated
+	    push hl
+__STRCONTINUE:	;   Pops hl and de SWAPPED
+	    pop de	;	DE = &a$
+	    pop hl	; 	HL = &b$
+	    ld a, d		; Return if not enough memory for new length
+	    or e
+	    ret z		; Return if DE == NULL (0)
+__STRCPY:	; Copies string pointed by HL into string pointed by DE
+	    ; Returns DE as HL (new pointer)
+	    ld a, h
+	    or l
+	    jr z, __NOTHING_TO_COPY
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl
+	    inc bc
+	    inc bc
+	    push de
+	    ldir
+	    pop hl
+	    ret
+__NOTHING_TO_COPY:
+	    ex de, hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    dec hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 14 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+	    push namespace core
+__PISTORE_STR:          ; Indirect assignment at (IX + BC)
+	    push ix
+	    pop hl
+	    add hl, bc
+__ISTORE_STR:           ; Indirect assignment, hl point to a pointer to a pointer to the heap!
+	    ld c, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, c             ; HL = (HL)
+__STORE_STR:
+	    push de             ; Pointer to b$
+	    push hl             ; Pointer to a$
+	    ld c, (hl)
+	    inc hl
+	    ld h, (hl)
+	    ld l, c             ; HL = (HL)
+	    call __STRASSIGN    ; HL (a$) = DE (b$); HL changed to a new dynamic memory allocation
+	    ex de, hl           ; DE = new address of a$
+	    pop hl              ; Recover variable memory address pointer
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d          ; Stores a$ ptr into element ptr
+	    pop hl              ; Returns ptr to b$ in HL (Caller might needed to free it from memory)
+	    ret
+	    pop namespace
+#line 63 "arch/zx48k/local_str_array4.bas"
+	END
diff --git a/tests/functional/arch/zx48k/local_str_array4.bas b/tests/functional/arch/zx48k/local_str_array4.bas
new file mode 100644
index 000000000..19095ffcc
--- /dev/null
+++ b/tests/functional/arch/zx48k/local_str_array4.bas
@@ -0,0 +1,8 @@
+DIM index As UInteger
+DIM TABLENAMES(10) AS STRING
+
+SUB Test (value As String, BYREF HighScoreNames() AS STRING)
+    LET HighScoreNames(index) = value
+END SUB
+
+Test("OUP", TABLENAMES)
diff --git a/tests/functional/arch/zx48k/ltee7.asm b/tests/functional/arch/zx48k/ltee7.asm
index 0fefc0ad0..5f068dba5 100644
--- a/tests/functional/arch/zx48k/ltee7.asm
+++ b/tests/functional/arch/zx48k/ltee7.asm
@@ -60,8 +60,8 @@ _setlocal:
 	ld de, -6
 	add hl, de
 	call .core.__ARRAY
-	pop de
-	call .core.__STORE_STR2
+	ld de, .LABEL.__LABEL0
+	call .core.__STORE_STR
 _setlocal__leave:
 	ex af, af'
 	exx
@@ -244,7 +244,7 @@ ARRAY_SIZE_LOOP:
 	    pop namespace
 #line 60 "arch/zx48k/ltee7.bas"
 #line 1 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -255,7 +255,7 @@ ARRAY_SIZE_LOOP:
 	; closed source programs).
 	;
 	; Please read the MIT license on the internet
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -349,8 +349,8 @@ __STOP:
 	    ld (ERR_NR), a
 	    ret
 	    pop namespace
-#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/heapinit.asm"
+#line 69 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/heapinit.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -457,7 +457,7 @@ __MEM_INIT2:
 	    ret
 	    ENDP
 	    pop namespace
-#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 70 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_ALLOC
 	;  Allocates a block of memory in the heap.
@@ -488,9 +488,9 @@ __MEM_START:
 __MEM_LOOP:  ; Loads lengh at (HL, HL+). If Lenght >= BC, jump to __MEM_DONE
 	    ld a, h ;  HL = NULL (No memory available?)
 	    or l
-#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 113 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ret z ; NULL
-#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/alloc.asm"
+#line 115 "/zxbasic/src/lib/arch/zx48k/runtime/mem/alloc.asm"
 	    ; HL = Pointer to Free block
 	    ld e, (hl)
 	    inc hl
@@ -555,7 +555,7 @@ __MEM_SUBTRACT:
 	    ret
 	    ENDP
 	    pop namespace
-#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/calloc.asm"
+#line 13 "/zxbasic/src/lib/arch/zx48k/runtime/mem/calloc.asm"
 	; ---------------------------------------------------------------------
 	; MEM_CALLOC
 	;  Allocates a block of memory in the heap, and clears it filling it
@@ -660,7 +660,7 @@ __ALLOC_INITIALIZED_LOCAL_ARRAY:
 	; This routine is in charge of freeing an array of strings from memory
 	; HL = Pointer to start of array in memory
 	; Top of the stack = Number of elements of the array
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/free.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/free.asm"
 ; vim: ts=4:et:sw=4:
 	; Copyleft (K) by Jose M. Rodriguez de la Rosa
 	;  (a.k.a. Boriel)
@@ -861,37 +861,252 @@ __ARRAYSTR_FREE_MEM: ; like the above, buf also frees the array itself
 	    jp __MEM_FREE	; Frees it and returns from __MEM_FREE
 	    pop namespace
 #line 62 "arch/zx48k/ltee7.bas"
-#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr2.asm"
-	; Similar to __STORE_STR, but this one is called when
-	; the value of B$ if already duplicated onto the stack.
-	; So we needn't call STRASSING to create a duplication
-	; HL = address of string memory variable
-	; DE = address of 2n string. It just copies DE into (HL)
-	; 	freeing (HL) previously.
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+; vim:ts=4:et:sw=4
+	; Stores value of current string pointed by DE register into address pointed by HL
+	; Returns DE = Address pointer  (&a$)
+	; Returns HL = HL               (b$ => might be needed later to free it from the heap)
+	;
+	; e.g. => HL = _variableName    (DIM _variableName$)
+	;         DE = Address into the HEAP
+	;
+	; This function will resize (REALLOC) the space pointed by HL
+	; before copying the content of b$ into a$
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+#line 1 "/zxbasic/src/lib/arch/zx48k/runtime/mem/realloc.asm"
+; vim: ts=4:et:sw=4:
+	; Copyleft (K) by Jose M. Rodriguez de la Rosa
+	;  (a.k.a. Boriel)
+;  http://www.boriel.com
+	;
+	; This ASM library is licensed under the BSD license
+	; you can use it for any purpose (even for commercial
+	; closed source programs).
+	;
+	; Please read the BSD license on the internet
+	; ----- IMPLEMENTATION NOTES ------
+	; The heap is implemented as a linked list of free blocks.
+; Each free block contains this info:
+	;
+	; +----------------+ <-- HEAP START
+	; | Size (2 bytes) |
+	; |        0       | <-- Size = 0 => DUMMY HEADER BLOCK
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   | <-- If Size > 4, then this contains (size - 4) bytes
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+   |
+	;   <Allocated>        | <-- This zone is in use (Already allocated)
+	; +----------------+ <-+
+	; | Size (2 bytes) |
+	; +----------------+
+	; | Next (2 bytes) |---+
+	; +----------------+   |
+	; | <free bytes...>|   |
+	; | (0 if Size = 4)|   |
+	; +----------------+ <-+
+	; | Next (2 bytes) |--> NULL => END OF LIST
+	; |    0 = NULL    |
+	; +----------------+
+	; | <free bytes...>|
+	; | (0 if Size = 4)|
+	; +----------------+
+	; When a block is FREED, the previous and next pointers are examined to see
+	; if we can defragment the heap. If the block to be breed is just next to the
+	; previous, or to the next (or both) they will be converted into a single
+	; block (so defragmented).
+	;   MEMORY MANAGER
+	;
+	; This library must be initialized calling __MEM_INIT with
+	; HL = BLOCK Start & DE = Length.
+	; An init directive is useful for initialization routines.
+	; They will be added automatically if needed.
+	; ---------------------------------------------------------------------
+	; MEM_REALLOC
+	;  Reallocates a block of memory in the heap.
+	;
+	; Parameters
+	;  HL = Pointer to the original block
+	;  BC = New Length of requested memory block
+	;
+; Returns:
+	;  HL = Pointer to the allocated block in memory. Returns 0 (NULL)
+	;       if the block could not be allocated (out of memory)
+	;
+; Notes:
+	;  If BC = 0, the block is freed, otherwise
+	;  the content of the original block is copied to the new one, and
+	;  the new size is adjusted. If BC < original length, the content
+	;  will be truncated. Otherwise, extra block content might contain
+	;  memory garbage.
+	;
+	; ---------------------------------------------------------------------
 	    push namespace core
-__PISTORE_STR2: ; Indirect store temporary string at (IX + BC)
+__REALLOC:    ; Reallocates block pointed by HL, with new length BC
+	    PROC
+	    LOCAL __REALLOC_END
+	    ld a, h
+	    or l
+	    jp z, __MEM_ALLOC    ; If HL == NULL, just do a malloc
+	    ld e, (hl)
+	    inc hl
+	    ld d, (hl)    ; DE = First 2 bytes of HL block
+	    push hl
+	    exx
+	    pop de
+	    inc de        ; DE' <- HL + 2
+	    exx            ; DE' <- HL (Saves current pointer into DE')
+	    dec hl        ; HL = Block start
+	    push de
+	    push bc
+	    call __MEM_FREE        ; Frees current block
+	    pop bc
+	    push bc
+	    call __MEM_ALLOC    ; Gets a new block of length BC
+	    pop bc
+	    pop de
+	    ld a, h
+	    or l
+	    ret z        ; Return if HL == NULL (No memory)
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    inc hl        ; Recovers first 2 bytes in HL
+	    dec bc
+	    dec bc        ; BC = BC - 2 (Two bytes copied)
+	    ld a, b
+	    or c
+	    jp z, __REALLOC_END        ; Ret if nothing to copy (BC == 0)
+	    exx
+	    push de
+	    exx
+	    pop de        ; DE <- DE' ; Start of remaining block
+	    push hl        ; Saves current Block + 2 start
+    ex de, hl    ; Exchanges them: DE is destiny block
+	    ldir        ; Copies BC Bytes
+	    pop hl        ; Recovers Block + 2 start
+__REALLOC_END:
+	    dec hl        ; Set HL
+	    dec hl        ; To begin of block
+	    ret
+	    ENDP
+	    pop namespace
+#line 2 "/zxbasic/src/lib/arch/zx48k/runtime/strcpy.asm"
+	; String library
+	    push namespace core
+__STRASSIGN: ; Performs a$ = b$ (HL = address of a$; DE = Address of b$)
+	    PROC
+	    LOCAL __STRREALLOC
+	    LOCAL __STRCONTINUE
+	    LOCAL __B_IS_NULL
+	    LOCAL __NOTHING_TO_COPY
+	    ld b, d
+	    ld c, e
+	    ld a, b
+	    or c
+	    jr z, __B_IS_NULL
+	    ex de, hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl		; BC = LEN(b$)
+	    ex de, hl	; DE = &b$
+__B_IS_NULL:		; Jumps here if B$ pointer is NULL
+	    inc bc
+	    inc bc		; BC = BC + 2  ; (LEN(b$) + 2 bytes for storing length)
+	    push de
+	    push hl
+	    ld a, h
+	    or l
+	    jr z, __STRREALLOC
+	    dec hl
+	    ld d, (hl)
+	    dec hl
+	    ld e, (hl)	; DE = MEMBLOCKSIZE(a$)
+	    dec de
+	    dec de		; DE = DE - 2  ; (Membloksize takes 2 bytes for memblock length)
+	    ld h, b
+	    ld l, c		; HL = LEN(b$) + 2  => Minimum block size required
+	    ex de, hl	; Now HL = BLOCKSIZE(a$), DE = LEN(b$) + 2
+	    or a		; Prepare to subtract BLOCKSIZE(a$) - LEN(b$)
+	    sbc hl, de  ; Carry if len(b$) > Blocklen(a$)
+	    jr c, __STRREALLOC ; No need to realloc
+	    ; Need to reallocate at least to len(b$) + 2
+	    ex de, hl	; DE = Remaining bytes in a$ mem block.
+	    ld hl, 4
+	    sbc hl, de  ; if remaining bytes < 4 we can continue
+	    jr nc,__STRCONTINUE ; Otherwise, we realloc, to free some bytes
+__STRREALLOC:
+	    pop hl
+	    call __REALLOC	; Returns in HL a new pointer with BC bytes allocated
+	    push hl
+__STRCONTINUE:	;   Pops hl and de SWAPPED
+	    pop de	;	DE = &a$
+	    pop hl	; 	HL = &b$
+	    ld a, d		; Return if not enough memory for new length
+	    or e
+	    ret z		; Return if DE == NULL (0)
+__STRCPY:	; Copies string pointed by HL into string pointed by DE
+	    ; Returns DE as HL (new pointer)
+	    ld a, h
+	    or l
+	    jr z, __NOTHING_TO_COPY
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    dec hl
+	    inc bc
+	    inc bc
+	    push de
+	    ldir
+	    pop hl
+	    ret
+__NOTHING_TO_COPY:
+	    ex de, hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    dec hl
+	    ret
+	    ENDP
+	    pop namespace
+#line 14 "/zxbasic/src/lib/arch/zx48k/runtime/storestr.asm"
+	    push namespace core
+__PISTORE_STR:          ; Indirect assignment at (IX + BC)
 	    push ix
 	    pop hl
 	    add hl, bc
-__ISTORE_STR2:
-	    ld c, (hl)  ; Dereferences HL
+__ISTORE_STR:           ; Indirect assignment, hl point to a pointer to a pointer to the heap!
+	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string variable address)
-__STORE_STR2:
-	    push hl
+	    ld l, c             ; HL = (HL)
+__STORE_STR:
+	    push de             ; Pointer to b$
+	    push hl             ; Pointer to a$
 	    ld c, (hl)
 	    inc hl
 	    ld h, (hl)
-	    ld l, c		; HL = *HL (real string address)
-	    push de
-	    call __MEM_FREE
-	    pop de
-	    pop hl
+	    ld l, c             ; HL = (HL)
+	    call __STRASSIGN    ; HL (a$) = DE (b$); HL changed to a new dynamic memory allocation
+	    ex de, hl           ; DE = new address of a$
+	    pop hl              ; Recover variable memory address pointer
 	    ld (hl), e
 	    inc hl
-	    ld (hl), d
-	    dec hl		; HL points to mem address variable. This might be useful in the future.
+	    ld (hl), d          ; Stores a$ ptr into element ptr
+	    pop hl              ; Returns ptr to b$ in HL (Caller might needed to free it from memory)
 	    ret
 	    pop namespace
 #line 63 "arch/zx48k/ltee7.bas"
diff --git a/tests/functional/arch/zx48k/opt2_arr_elem_by_ref01.asm b/tests/functional/arch/zx48k/opt2_arr_elem_by_ref01.asm
new file mode 100644
index 000000000..a2d747ed2
--- /dev/null
+++ b/tests/functional/arch/zx48k/opt2_arr_elem_by_ref01.asm
@@ -0,0 +1,74 @@
+	org 32768
+.core.__START_PROGRAM:
+	di
+	push ix
+	push iy
+	exx
+	push hl
+	exx
+	ld (.core.__CALL_BACK__), sp
+	ei
+	jp .core.__MAIN_PROGRAM__
+.core.__CALL_BACK__:
+	DEFW 0
+.core.ZXBASIC_USER_DATA:
+	; Defines USER DATA Length in bytes
+.core.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_END - .core.ZXBASIC_USER_DATA
+	.core.__LABEL__.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_LEN
+	.core.__LABEL__.ZXBASIC_USER_DATA EQU .core.ZXBASIC_USER_DATA
+_a:
+	DEFW .LABEL.__LABEL0
+_a.__DATA__.__PTR__:
+	DEFW _a.__DATA__
+	DEFW 0
+	DEFW 0
+_a.__DATA__:
+	DEFB 01h
+	DEFB 02h
+	DEFB 03h
+.LABEL.__LABEL0:
+	DEFW 0000h
+	DEFB 01h
+.core.ZXBASIC_USER_DATA_END:
+.core.__MAIN_PROGRAM__:
+	ld hl, _a.__DATA__
+	inc hl
+	push hl
+	call _Incr
+	ld a, (_a.__DATA__ + 1)
+	ld (0), a
+	ld hl, 0
+	ld b, h
+	ld c, l
+.core.__END_PROGRAM:
+	di
+	ld hl, (.core.__CALL_BACK__)
+	ld sp, hl
+	exx
+	pop hl
+	pop iy
+	pop ix
+	exx
+	ei
+	ret
+_Incr:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld a, (hl)
+	inc a
+	ld h, (ix+5)
+	ld l, (ix+4)
+	ld (hl), a
+_Incr__leave:
+	ld sp, ix
+	pop ix
+	exx
+	pop hl
+	ex (sp), hl
+	exx
+	ret
+	;; --- end of user code ---
+	END
diff --git a/tests/functional/arch/zx48k/opt2_arr_elem_by_ref01.bas b/tests/functional/arch/zx48k/opt2_arr_elem_by_ref01.bas
new file mode 100644
index 000000000..d4e8fc9af
--- /dev/null
+++ b/tests/functional/arch/zx48k/opt2_arr_elem_by_ref01.bas
@@ -0,0 +1,10 @@
+REM Test passing an array element by ref
+
+DIM a(2) As UByte => {1, 2, 3}
+
+SUB Incr(ByRef x As UByte)
+  LET x = x + 1
+END SUB
+
+Incr(a(1))
+POKE 0, a(1)