diff --git a/src/arch/z80/visitor/function_translator.py b/src/arch/z80/visitor/function_translator.py
index fc790f522..26257203e 100644
--- a/src/arch/z80/visitor/function_translator.py
+++ b/src/arch/z80/visitor/function_translator.py
@@ -69,21 +69,19 @@ def visit_FUNCTION(self, node):
                 lbound_label = local_var.mangled + ".__LBOUND__"
                 ubound_label = local_var.mangled + ".__UBOUND__"
                 lbound_needed = not local_var.is_zero_based and (
-                    local_var.is_dynamically_accessed or local_var.lbound_used
+                    local_var.is_dynamically_accessed or local_var.lbound_used or OPTIONS.array_check
                 )
+                ubound_needed = local_var.ubound_used or OPTIONS.array_check
+                bound_ptrs = [lbound_label if lbound_needed else "0", ubound_label if ubound_needed else "0"]
 
-                bound_ptrs = [lbound_label if lbound_needed else "0", "0"]
-                if local_var.ubound_used:
-                    bound_ptrs[1] = ubound_label
-
-                if bound_ptrs != ["0", "0"]:
+                if lbound_needed or ubound_needed:
                     OPTIONS["__DEFINES"].value["__ZXB_USE_LOCAL_ARRAY_WITH_BOUNDS__"] = ""
 
                 if lbound_needed:
                     l = ["%04X" % bound.lower for bound in local_var.bounds]
                     bound_tables.append(LabelledData(lbound_label, l))
 
-                if local_var.ubound_used:
+                if ubound_needed:
                     l = ["%04X" % bound.upper for bound in local_var.bounds]
                     bound_tables.append(LabelledData(ubound_label, l))
 
diff --git a/src/arch/z80/visitor/translator_visitor.py b/src/arch/z80/visitor/translator_visitor.py
index 331ec4aa9..6cb8790f6 100644
--- a/src/arch/z80/visitor/translator_visitor.py
+++ b/src/arch/z80/visitor/translator_visitor.py
@@ -128,8 +128,11 @@ def runtime_call(self, label: str, num: int):
         if label in LABEL_REQUIRED_MODULES:
             backend.REQUIRES.add(LABEL_REQUIRED_MODULES[label])
 
-    # This function must be called before emit_strings
     def emit_data_blocks(self):
+        """Emits the DATA instruction blocks used by READ.
+        This function must be called before emit_strings() because it will emit access to string variables,
+        marking them as required.
+        """
         if not gl.DATA_IS_USED or not gl.DATAS:
             return  # nothing to do
 
@@ -254,10 +257,12 @@ def traverse_const(node):
         raise InvalidCONSTexpr(node)
 
     @staticmethod
-    def check_attr(node, n):
+    def check_attr(node: Symbol, n: int) -> Symbol | None:
         """Check if ATTR has to be normalized
         after this instruction has been translated
         to intermediate code.
         """
         if len(node.children) > n:
             return node.children[n]
+
+        return None
diff --git a/tests/functional/arch/zx48k/local_array_with_bounds2.asm b/tests/functional/arch/zx48k/local_array_with_bounds2.asm
new file mode 100644
index 000000000..522f32f9e
--- /dev/null
+++ b/tests/functional/arch/zx48k/local_array_with_bounds2.asm
@@ -0,0 +1,917 @@
+	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 _Sub1
+	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
+_Sub1:
+	push ix
+	ld ix, 0
+	add ix, sp
+	ld hl, -7
+	add hl, sp
+	ld sp, hl
+	ld (hl), 0
+	ld bc, 6
+	ld d, h
+	ld e, l
+	inc de
+	ldir
+	ld hl, _Sub1.a.__UBOUND__
+	push hl
+	ld hl, 0
+	push hl
+	ld hl, -7
+	ld de, .LABEL.__LABEL0
+	ld bc, 6
+	call .core.__ALLOC_LOCAL_ARRAY_WITH_BOUNDS
+	ld (ix-1), 2
+	ld a, (ix-1)
+	dec a
+	ld l, a
+	ld h, 0
+	push hl
+	push ix
+	pop hl
+	ld de, -7
+	add hl, de
+	call .core.__ARRAY
+	ld de, 7
+	ld (hl), e
+	inc hl
+	ld (hl), d
+	ld l, (ix-5)
+	ld h, (ix-4)
+	inc hl
+	inc hl
+	ld a, (hl)
+	inc hl
+	ld h, (hl)
+	ld l, a
+	ld (0), a
+_Sub1__leave:
+	ex af, af'
+	exx
+	ld l, (ix-5)
+	ld h, (ix-4)
+	call .core.__MEM_FREE
+	ex af, af'
+	exx
+	ld sp, ix
+	pop ix
+	ret
+_Sub1.a.__UBOUND__:
+	DEFW 0002h
+	;; --- 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 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 23 "/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
+	    inc hl
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)  ; BC <-- Array __UBOUND__ PTR
+	    ld (UBOUND_PTR), bc
+#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
+	    ld a, ERROR_SubscriptWrong
+	    jp c, __ERROR
+	    push hl     ; Saves (Ai) - Lbound(i)
+	    add hl, bc  ; Recover original (Ai) value
+	    push hl
+	    ld hl, (UBOUND_PTR)
+	    ld c, (hl)
+	    inc hl
+	    ld b, (hl)
+	    inc hl
+	    ld (UBOUND_PTR), hl
+	    pop hl      ; original (Ai) value
+	    scf
+	    sbc hl, bc  ; HL <- HL - BC - 1 = Ai - UBound(i) - 1 => No Carry if Ai > UBound(i)
+	    jp nc, __ERROR
+	    pop hl  ; Recovers (Ai) - Lbound(Ai)
+#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/local_array_with_bounds2.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/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
+	; ---------------------------------------------------------------------
+	; __ALLOC_LOCAL_ARRAY_WITH_BOUNDS
+	;  Allocates an array element area in the heap, and clears it filling it
+	;  with 0 bytes. Then sets LBOUND and UBOUND ptrs
+	;
+	; 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 lbound element area
+	;  [SP + 4] PTR to the ubound element area
+	;
+; Returns:
+	;  HL = (IX + HL) + 8
+	; ---------------------------------------------------------------------
+__ALLOC_LOCAL_ARRAY_WITH_BOUNDS:
+	    call __ALLOC_LOCAL_ARRAY
+__ALLOC_LOCAL_ARRAY_WITH_BOUNDS2:
+	    pop bc   ;; ret address
+	    pop de   ;; lbound
+	    inc hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    pop de   ;; PTR to ubound table
+	    push bc  ;; puts ret address back
+	    ld a, d
+	    or e
+	    ret z    ;; if PTR for UBound is 0, it's not used
+	    inc hl
+	    ld (hl), e
+	    inc hl
+	    ld (hl), d
+	    ret
+	; ---------------------------------------------------------------------
+	; __ALLOC_INITIALIZED_LOCAL_ARRAY_WITH_BOUNDS
+	;  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
+	;  TOP of the stack = PTR to the element area
+	;  [SP + 2] = PTR to the element area
+	;  [SP + 4] = PTR to the lbound element area
+	;  [SP + 6] = PTR to the ubound element area
+	;
+; Returns:
+	;  HL = (IX + HL) + 8
+	; ---------------------------------------------------------------------
+__ALLOC_INITIALIZED_LOCAL_ARRAY_WITH_BOUNDS:
+	    ;; Swaps [SP] and [SP + 2]
+	    exx
+	    pop hl       ;; Ret address
+	    ex (sp), hl  ;; HL <- PTR to Element area, (sp) = Ret address
+	    push hl      ;; [SP] = PTR to element area, [SP + 2] = Ret address
+	    exx
+	    call __ALLOC_INITIALIZED_LOCAL_ARRAY
+	    jp __ALLOC_LOCAL_ARRAY_WITH_BOUNDS2
+#line 142 "/zxbasic/src/lib/arch/zx48k/runtime/array/arrayalloc.asm"
+	    pop namespace
+#line 77 "arch/zx48k/local_array_with_bounds2.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/local_array_with_bounds2.bas"
+.LABEL.__LABEL0:
+	DEFB 00h
+	DEFB 00h
+	DEFB 02h
+	END
diff --git a/tests/functional/arch/zx48k/local_array_with_bounds2.bas b/tests/functional/arch/zx48k/local_array_with_bounds2.bas
new file mode 100644
index 000000000..d47c7053f
--- /dev/null
+++ b/tests/functional/arch/zx48k/local_array_with_bounds2.bas
@@ -0,0 +1,15 @@
+#pragma array_check=true
+
+sub Sub1()
+    dim i as uByte
+    dim a(2) as uInteger
+
+    i=2
+    a(i-1)=7
+
+    POKE 0,a(1)
+end sub
+
+
+
+Sub1