```;   _____ _              _     __          __            _
;  / ____| |            | |    \ \        / /           | |
; | (___ | |_  __ _  ___| | __  \ \  /\  / /___  _ __ __| |___
;  \___ \| __|/ _` |/ __| |/ /   \ \/  \/ // _ \| '__/ _` / __|
;  ____) | |_| (_| | (__|   <     \  /\  /| (_) | | | (_| \__ \
; |_____/ \__|\__,_|\___|_|\_\     \/  \/  \___/|_|  \__,_|___/
; Core words pertaining to data and return stack manipulation

; PICK ( x1 x2 x3 x4 n -- x1 x2 x3 x4 x5 )
; picks the nth value from the data stack and places a copy of it on the top
; of the data stack.
; note: parameters start from 0. 0 PICK is equivalent to DUP.
; 1 PICK is equivalent to OVER
_pick   mov *stack,r6               ; get required stack parameter number
inc r6                      ; adjust for parameter n on stack
sla r6,1                    ; convert to byte offset
pickx   b @retB0                    ; NEXT

; ROLL ( +n -- n )
; The +nth stack value, not counting +n itself is first removed and then
; transferred to the top of the stack, moving the remaining values into the
; vacated position.  {0..the number of elements on the stack-1}
; 2 ROLL is equivalent to ROT. 0 ROLL is a null operation
_roll   mov *stack+,r8              ; pop roll value in r8
mov r8,r8                   ; test for zero value
jeq pickx                   ; if zero, take no action
mov stack,r10               ; copy stack pointer
mov r8,r9                   ; copy roll value
sla r8,1                    ; multiply by two, to get the offset into
; the stack
a r8,r10                    ; compute stack address to start from
mov *r10,r0                 ; store stack value, this will go to TOS
mov r10,r1                  ; move everything above this stack entry
; back one
dect r10                    ; source
rolllp  mov *r10,*r1                ; move source back one word
dect r10
dect r1
dec r9                      ; decrement counter. finished?
jne rolllp                  ; loop if not
mov r0,*stack               ; place earlier saved value to TOS
exroll  jmp pickx                   ; NEXT

; DEPTH ( -- depth )
; depth is the number of 16-bit values contained in the data stack before depth
; was placed on the stack.
_depth  mov stack,r7                ; copy address of TOS
inct r7
mov @s0,r6                  ; base of stack
s r7,r6                     ; subtract tos from base of stack
sra r6,1                    ; convert to cells
dect stack                  ; new stack entry
mov r6,*stack               ; push depth
jmp pickx                   ; NEXT

```