0010 <__trap_interrupt>
0010:    ret
4400 <__init_stack>
4400:    mov	#0x4400, sp
4404 <__low_level_init>
4404:    mov	&0x015c, r5
4408:    and.b	#-0x1, r5
440a:    bis	#0x5a08, r5
440e <__do_copy_data>
440e:    mov	#0x6, r15
4412:    tst	r15
4414:    jz	$4424 
4416:    mov	r5, &0x015c
441a:    decd	r15
441c:    mov	0x4d9e(r15), 0x2400(r15)
4422:    jnz	$4416 
4424 <__do_clear_bss>
4424:    clr	r15
4428:    tst	r15
442a:    jz	$4438 
442c:    mov	r5, &0x015c
4430:    dec	r15
4432:    mov.b	#0x0, 0x2406(r15)
4436:    jnz	$442c 
4438 <main>
4438:    sub	#0x8, sp
443a:    call	$4b66 <run>
443e <__stop_progExec__>
443e:    bis	#0xf0, sr
4442:    jmp	$443e 
4444 <__ctors_end>
4444:    br	#0x4d9c <_unexpected_>
4448 <printf>
4448:    push	r11
444a:    push	r10
444c:    push	r9
444e:    push	r8
4450:    push	r7
4452:    push	r6
4454:    push	r4
4456:    mov	sp, r4
4458:    add	#0xe, r4
445c:    decd	sp
445e:    mov	0x2(r4), r11
4462:    mov	sp, -0x10(r4)
4466:    mov	r11, r15
4468:    clr	r14
446a:    jmp	$4482 
446c:    inc	r15
446e:    cmp.b	#0x25, r13
4472:    jnz	$4482 
4474:    cmp.b	@r15, r13
4476:    jnz	$447e 
4478:    inc	r15
447a:    clr	r13
447c:    jmp	$4480 
447e:    mov	#0x1, r13
4480:    add	r13, r14
4482:    mov.b	@r15, r13
4484:    tst.b	r13
4486:    jnz	$446c 
4488:    mov	r14, r15
448a:    add	r15, r15
448c:    incd	r15
448e:    sub	r15, sp
4490:    mov	sp, r9
4492:    mov	r4, r12
4494:    add	#0x4, r12
4496:    mov	sp, r15
4498:    clr	r13
449a:    jmp	$44a6 
449c:    mov	@r12, 0x0(r15)
44a0:    inc	r13
44a2:    incd	r15
44a4:    incd	r12
44a6:    cmp	r14, r13
44a8:    jl	$449c 
44aa:    clr	r10
44ac:    mov	#0x9, r6
44b0:    jmp	$454a 
44b2:    mov	r11, r8
44b4:    inc	r8
44b6:    cmp.b	#0x25, r15
44ba:    jz	$44c8 
44bc:    inc	r10
44be:    mov	r8, r11
44c0:    sxt	r15
44c2:    call	$4d04 <putchar>
44c6:    jmp	$454a 
44c8:    mov.b	@r8, r14
44ca:    cmp.b	r15, r14
44cc:    jnz	$44da 
44ce:    inc	r10
44d0:    mov	#0x25, r15
44d4:    call	$4d04 <putchar>
44d8:    jmp	$4544 
44da:    cmp.b	#0x73, r14
44de:    jnz	$44f6 
44e0:    mov	@r9, r11
44e2:    jmp	$44ee 
44e4:    inc	r10
44e6:    inc	r11
44e8:    sxt	r15
44ea:    call	$4d04 <putchar>
44ee:    mov.b	@r11, r15
44f0:    tst.b	r15
44f2:    jnz	$44e4 
44f4:    jmp	$4544 
44f6:    cmp.b	#0x78, r14
44fa:    jnz	$4538 
44fc:    mov	@r9, r11
44fe:    mov	#0x4, r7
4500:    jmp	$452e 
4502:    mov	r11, r15
4504:    swpb	r15
4506:    and	#0xff, r15
450a:    clrc
450c:    rrc	r15
450e:    rra	r15
4510:    rra	r15
4512:    rra	r15
4514:    cmp	r15, r6
4516:    jl	$451e 
4518:    add	#0x30, r15
451c:    jmp	$4522 
451e:    add	#0x57, r15
4522:    call	$4d04 <putchar>
4526:    add	r11, r11
4528:    add	r11, r11
452a:    add	r11, r11
452c:    add	r11, r11
452e:    add	#-0x1, r7
4530:    cmp	#-0x1, r7
4532:    jnz	$4502 
4534:    add	#0x4, r10
4536:    jmp	$4544 
4538:    cmp.b	#0x6e, r14
453c:    jnz	$4544 
453e:    mov	@r9, r15
4540:    mov	r10, 0x0(r15)
4544:    incd	r9
4546:    mov	r8, r11
4548:    inc	r11
454a:    mov.b	@r11, r15
454c:    tst.b	r15
454e:    jnz	$44b2 
4550:    mov	-0x10(r4), sp
4554:    incd	sp
4556:    pop	r4
4558:    pop	r6
455a:    pop	r7
455c:    pop	r8
455e:    pop	r9
4560:    pop	r10
4562:    pop	r11
4564:    ret
45ba <walk>
45ba:    push	r11
45bc:    push	r10
45be:    push	r9
45c0:    mov	r15, r11
45c2:    mov	#0x4566, r15
45c6:    call	$4d50 <puts>
45ca:    mov	0x4(r11), r15
45ce:    mov	r15, r14
45d0:    and	#0x1, r14
45d2:    clrc
45d4:    rrc	r15
45d6:    tst	r14
45d8:    jz	$4636 
45da:    push	r15
45dc:    push	0x2(r11)
45e0:    push	@r11
45e2:    push	r11
45e4:    push	#0x4569
45e8:    call	$4448 <printf>
45ec:    add	#0xa, sp
45f0:    mov	r11, r10
45f2:    add	#0x6, r10
45f6:    push	r10
45f8:    push	#0x458b
45fc:    call	$4448 <printf>
4600:    add	#0x4, sp
4602:    clr	r9
4604:    jmp	$4616 
4606:    push	@r10
4608:    push	#0x4594
460c:    call	$4448 <printf>
4610:    add	#0x4, sp
4612:    inc	r9
4614:    incd	r10
4616:    mov	0x4(r11), r15
461a:    clrc
461c:    rrc	r15
461e:    rra	r15
4620:    cmp	r15, r9
4622:    jnc	$4606 
4624:    mov	#0x5d, r15
4628:    call	$4d04 <putchar>
462c:    mov	#0xa, r15
4630:    call	$4d04 <putchar>
4634:    jmp	$464c 
4636:    push	r15
4638:    push	0x2(r11)
463c:    push	@r11
463e:    push	r11
4640:    push	#0x4598
4644:    call	$4448 <printf>
4648:    add	#0xa, sp
464c:    mov	0x2(r11), r11
4650:    cmp	&0x2400, r11
4654:    jnz	$45ca 
4656:    pop	r9
4658:    pop	r10
465a:    pop	r11
465c:    ret
465e:    addc.b	r5, r8
4660:    subc.b	@pc, sp
4662:    addc	@r5, pc
4664:    addc.b	@sp+, r8
4666:    subc.b	#-0x1, r5
4668:    addc.b	@r5+, r4
466a:    jl	$4534 
466c:    addc	@sp, pc
466e:    addc.b	@r15, sr
4670:    subc.b	@r4+, sr
4672:    addc.b	@r14, r9
4674:    jc	$4344 
4678 <malloc>
4678:    push	r11
467a:    tst.b	&0x2404
467e:    jz	$469e 
4680:    mov	&0x2400, r14
4684:    mov	r14, 0x0(r14)
4688:    mov	r14, 0x2(r14)
468c:    mov	&0x2402, r13
4690:    add	#0xfffa, r13
4694:    add	r13, r13
4696:    mov	r13, 0x4(r14)
469a:    mov.b	#0x0, &0x2404
469e:    mov	&0x2400, r11
46a2:    mov	r11, r14
46a4:    mov	0x4(r14), r13
46a8:    bit	#0x1, r13
46aa:    jnz	$46fc 
46ac:    mov	r13, r12
46ae:    clrc
46b0:    rrc	r12
46b2:    cmp	r15, r12
46b4:    jl	$46fc 
46b6:    mov	r15, r11
46b8:    add	#0x6, r11
46bc:    cmp	r11, r12
46be:    jc	$46c8 
46c0:    bis	#0x1, r13
46c2:    mov	r13, 0x4(r14)
46c6:    jmp	$46f4 
46c8:    mov	r15, r13
46ca:    add	r13, r13
46cc:    bis	#0x1, r13
46ce:    mov	r13, 0x4(r14)
46d2:    mov	r14, r13
46d4:    add	#0x6, r13
46d8:    add	r15, r13
46da:    mov	r14, 0x0(r13)
46de:    mov	0x2(r14), 0x2(r13)
46e4:    sub	r15, r12
46e6:    add	#0xfffa, r12
46ea:    add	r12, r12
46ec:    mov	r12, 0x4(r13)
46f0:    mov	r13, 0x2(r14)
46f4:    mov	r14, r15
46f6:    add	#0x6, r15
46fa:    jmp	$4718 
46fc:    mov	r14, r13
46fe:    mov	0x2(r14), r14
4702:    cmp	r13, r14
4704:    jnc	$470a 
4706:    cmp	r11, r14
4708:    jnz	$46a4 
470a:    mov	#0x465e, r15
470e:    call	$4d50 <puts>
4712:    br	#0x443e <__stop_progExec__>
4716:    clr	r15
4718:    pop	r11
471a:    ret
471c <free>                      ; r15_pMemoryBlock; (offsetPrev=0x0, offsetNext=0x2, offsetStatus=0x4, cbSize=6)
471c:    push	r11                ; save r11
471e:    add	#0xfffa, r15       ; r15_pControlBlock = (pMemoryBlock - cbSize))
4722:    mov	0x4(r15), r13      ; r13_ControlBlockStatus = *(r15_pControlBlock + offsetStatus)
4726:    and	#0xfffe, r13       ; r13_ControlBlockStatus clear [alloc] flag
472a:    mov	r13, 0x4(r15)      ; write status back with cleared alloc flag
472e:    mov	@r15, r14          ; r14_pControlBlockPrev = *(r15_pControlBlock + offsetPrev)
4730:    mov	0x4(r14), r12      ; r12_PrevControlBlockStatus = *(r14_pControlBlockPrev + offsetStatus)
4734:    bit	#0x1, r12          ; check if prev block is [alloc]
4736:    jnz	$4752              ; jump if prevControlBlock is [alloc] else if [free] continue
4738:    add	#0x6, r12          ; r12_PrevControlBlockStatus += cbSize
473c:    add	r13, r12           ; r12_PrevControlBlockStatus += r13_ControlBlockStatus 
473e:    mov	r12, 0x4(r14)      ; *(r14_pControlBlockPrev + offsetStatus) = r12_PrevControlBlockStatus 
4742:    mov	0x2(r15), 0x2(r14) ; *(r14_pControlBlockPrev + offsetNext) = *(r15_pControlBlock + offsetNext)
4748:    mov	0x2(r15), r13      ; r13_pControlBlockNext = *(r15_pControlBlock + offsetNext)
474c:    mov	r14, 0x0(r13)      ; (*r13_pControlBlockNext + offsetPrev) = r14_pControlBlockPrev
4750:    mov	@r15, r15          ; r15_pControlBlock = *(r15_pControlBlock + offsetPrev)
4752:    mov	0x2(r15), r14      ; r14_pNextBlock
4756:    mov	0x4(r14), r13      ; r14_NextBlockStatus
475a:    bit	#0x1, r13
475c:    jnz	$4774 
475e:    add	0x4(r15), r13
4762:    add	#0x6, r13
4766:    mov	r13, 0x4(r15)
476a:    mov	0x2(r14), 0x2(r15)
4770:    mov	r15, 0x0(r14)
4774:    pop	r11
4776:    ret
4778 <create_hash_table>
4778:    push	r11
477a:    push	r10
477c:    push	r9
477e:    push	r8
4780:    push	r7
4782:    push	r6
4784:    mov	r15, r7
4786:    mov	r14, r9
4788:    mov	#0xa, r15
478c:    call	$4678 <malloc>
4790:    mov	r15, r10
4792:    clr	0x0(r15)
4796:    mov	r7, 0x2(r15)
479a:    mov	r9, 0x4(r15)
479e:    mov	#0x2, r11
47a0:    mov	r7, r15
47a2:    tst	r15
47a4:    jz	$47ac 
47a6:    add	r11, r11
47a8:    dec	r15
47aa:    jnz	$47a6 
47ac:    mov	r11, r15
47ae:    call	$4678 <malloc>
47b2:    mov	r15, 0x6(r10)
47b6:    mov	r11, r15
47b8:    call	$4678 <malloc>
47bc:    mov	r15, 0x8(r10)
47c0:    mov	#0x1, r8
47c2:    tst	r7
47c4:    jz	$47cc 
47c6:    add	r8, r8
47c8:    dec	r7
47ca:    jnz	$47c6 
47cc:    mov	r9, r11
47ce:    add	r11, r11
47d0:    add	r11, r11
47d2:    add	r11, r11
47d4:    add	r9, r11
47d6:    add	r11, r11
47d8:    clr	r9
47da:    jmp	$47fa 
47dc:    mov	r9, r7
47de:    add	r7, r7
47e0:    mov	0x6(r10), r6
47e4:    add	r7, r6
47e6:    mov	r11, r15
47e8:    call	$4678 <malloc>
47ec:    mov	r15, 0x0(r6)
47f0:    add	0x8(r10), r7
47f4:    clr	0x0(r7)
47f8:    inc	r9
47fa:    cmp	r8, r9
47fc:    jl	$47dc 
47fe:    mov	r10, r15
4800:    pop	r6
4802:    pop	r7
4804:    pop	r8
4806:    pop	r9
4808:    pop	r10
480a:    pop	r11
480c:    ret
480e <hash>                                    ; r15=pName -> r15
480e:    mov	r15, r14                         ; hashes string in r15
4810:    clr	r15                              ; and returns hash in r15
4812:    jmp	$482a 
4814:    mov.b	@r14, r13
4816:    sxt	r13
4818:    add	r15, r13
481a:    mov	r13, r15
481c:    add	r15, r15
481e:    add	r15, r15
4820:    add	r15, r15
4822:    add	r15, r15
4824:    add	r15, r15
4826:    sub	r13, r15
4828:    inc	r14
482a:    tst.b	0x0(r14)
482e:    jnz	$4814 
4830:    ret
4832 <add_to_table> r15_hash_table_root, 14_p_user_name, r13_hashed_pin
4832:    push	r11
4834:    push	r10
4836:    push	r9
4838:    mov	r15, r11         ; r11_hash_table_root
483a:    mov	r14, r10         ; r10_p_user_name
483c:    mov	r13, r9          ; r9_hashed_pin
483e:    mov	0x2(r15), r14    ; r14_hash_table+2 (3?)
4842:    mov	0x4(r15), r12    ; r12_hash_table+4 (5?)
4846:    mov	r14, r15         ; r15_hash_table+2 (3?)
4848:    tst	r15
484a:    jz	$4852 
484c:    add	r12, r12         ; r12 += r12
484e:    dec	r15              ; r15--
4850:    jnz	$484c            ; r12_hash_table+2 *= (2**hash_table+4) (20?)
4852:    tst	r12
4854:    jge	$485a 
4856:    add	#0x3, r12
485a:    rra	r12
485c:    rra	r12
485e:    cmp	@r11, r12
4860:    jge	$486a 
4862:    inc	r14
4864:    mov	r11, r15
4866:    call	$48d4 <rehash>
486a:    inc	0x0(r11)
486e:    mov	r10, r15
4870:    call	$480e <hash>
4874:    mov	#0x1, r12
4876:    mov	0x2(r11), r14
487a:    tst	r14
487c:    jz	$4884 
487e:    add	r12, r12
4880:    dec	r14
4882:    jnz	$487e 
4884:    add	#-0x1, r12
4886:    and	r15, r12
4888:    add	r12, r12
488a:    mov	0x8(r11), r15
488e:    add	r12, r15
4890:    mov	@r15, r14
4892:    mov	0x6(r11), r11
4896:    add	r12, r11
4898:    mov	r14, r12
489a:    add	r12, r12
489c:    add	r12, r12
489e:    add	r12, r12
48a0:    add	r14, r12
48a2:    add	r12, r12
48a4:    add	@r11, r12
48a6:    inc	r14
48a8:    mov	r14, 0x0(r15)
48ac:    clr	r15
48ae:    jmp	$48c2 
48b0:    mov	r12, r11
48b2:    add	r15, r11
48b4:    mov.b	r14, 0x0(r11)
48b8:    inc	r15
48ba:    cmp	#0xf, r15
48be:    jz	$48c8 
48c0:    inc	r10
48c2:    mov.b	@r10, r14
48c4:    tst.b	r14
48c6:    jnz	$48b0 
48c8:    mov	r9, 0x10(r12)
48cc:    pop	r9
48ce:    pop	r10
48d0:    pop	r11
48d2:    ret
48d4 <rehash>
48d4:    push	r11
48d6:    push	r10
48d8:    push	r9
48da:    push	r8
48dc:    push	r7
48de:    push	r6
48e0:    push	r5
48e2:    push	r4
48e4:    decd	sp
48e6:    mov	r15, r11
48e8:    mov	0x2(r15), r6
48ec:    mov	0x6(r15), r5
48f0:    mov	0x8(r15), r4
48f4:    mov	r14, 0x2(r15)
48f8:    clr	0x0(r15)
48fc:    mov	#0x2, r10
48fe:    tst	r14
4900:    jz	$4908 
4902:    add	r10, r10
4904:    dec	r14
4906:    jnz	$4902 
4908:    mov	r10, r15
490a:    call	$4678 <malloc>
490e:    mov	r15, 0x6(r11)
4912:    mov	r10, r15
4914:    call	$4678 <malloc>
4918:    mov	r15, 0x8(r11)
491c:    clr	r10
491e:    mov	#0x1, r8
4920:    jmp	$4950 
4922:    mov	r10, r9
4924:    add	r9, r9
4926:    mov	0x6(r11), r7
492a:    add	r9, r7
492c:    mov	0x4(r11), r15
4930:    mov	r15, r14
4932:    add	r14, r14
4934:    add	r14, r14
4936:    add	r14, r14
4938:    add	r15, r14
493a:    mov	r14, r15
493c:    add	r15, r15
493e:    call	$4678 <malloc>
4942:    mov	r15, 0x0(r7)
4946:    add	0x8(r11), r9
494a:    clr	0x0(r9)
494e:    inc	r10
4950:    mov	0x2(r11), r13
4954:    mov	r8, r14
4956:    tst	r13
4958:    jz	$4960 
495a:    add	r14, r14
495c:    dec	r13
495e:    jnz	$495a 
4960:    cmp	r14, r10
4962:    jl	$4922 
4964:    mov	r6, r15
4966:    mov	#0x1, r14
4968:    tst	r15
496a:    jz	$4972 
496c:    add	r14, r14
496e:    dec	r15
4970:    jnz	$496c 
4972:    mov	r14, 0x0(sp)
4976:    mov	r5, r10
4978:    mov	r4, r9
497a:    clr	r7
497c:    jmp	$49a8 
497e:    mov	@r10, r14
4980:    add	r8, r14
4982:    mov	0x10(r14), r13
4986:    mov	r11, r15
4988:    call	$4832 <add_to_table>
498c:    inc	r6
498e:    add	#0x12, r8
4992:    jmp	$4998 
4994:    clr	r8
4996:    mov	r8, r6
4998:    cmp	@r9, r6
499a:    jl	$497e 
499c:    mov	@r10, r15
499e:    call	$471c <free>
49a2:    inc	r7
49a4:    incd	r10
49a6:    incd	r9
49a8:    cmp	@sp, r7
49aa:    jl	$4994 
49ac:    mov	r4, r15
49ae:    call	$471c <free>
49b2:    mov	r5, r15
49b4:    call	$471c <free>
49b8:    incd	sp
49ba:    pop	r4
49bc:    pop	r5
49be:    pop	r6
49c0:    pop	r7
49c2:    pop	r8
49c4:    pop	r9
49c6:    pop	r10
49c8:    pop	r11
49ca:    ret
49cc <get_from_table> r13=hashedPin, r14=pName, r15=pHashTableRoot
49cc:    push	r11
49ce:    push	r10
49d0:    push	r9
49d2:    push	r8
49d4:    push	r7
49d6:    push	r6
49d8:    mov	r15, r10                 ; r10=pHashTableRoot
49da:    mov	r14, r6                  ; r6=pName
49dc:    mov	r14, r15                 ; r15=pName
49de:    call	$480e <hash>             ; (r15=pName); r15=hashedName
49e2:    mov	#0x1, r11                ; r11=1
49e4:    mov	0x2(r10), r13            ; r13=? *(pHashTableRoot + 2)
49e8:    tst	r13                      ; [r11 = 2**r13]
49ea:    jz	$49f2                      ; jump if r13 == 0
49ec:    add	r11, r11                 ; r11 *= 2
49ee:    dec	r13                      ; r13--
49f0:    jnz	$49ec                    ; while r13 != 0
49f2:    add	#-0x1, r11               ; r11--
49f4:    and	r15, r11                 ; r11 &= r15
49f6:    add	r11, r11                 ; r11 *= 2
49f8:    mov	0x6(r10), r13            ; r13=? *(pHashTableRoot + 6)
49fc:    add	r11, r13                 ; r13 += r11
49fe:    mov	@r13, r9                 ; r9 = (first element?)
4a00:    clr	r8                       ;
4a02:    jmp	$4a1e                    ;
4a04:    mov	r9, r7
4a06:    mov	r9, r14
4a08:    mov	r6, r15
4a0a:    call	$4d7c <strcmp>
4a0e:    add	#0x12, r9
4a12:    tst	r15
4a14:    jnz	$4a1c 
4a16:    mov	0x10(r7), r15
4a1a:    jmp	$4a2a 
4a1c:    inc	r8
4a1e:    mov	0x8(r10), r15            ; r15=? *(pHashTableRoot + 8)
4a22:    add	r11, r15                 ;
4a24:    cmp	@r15, r8                 ;
4a26:    jl	$4a04                      ; jump if @r15 is negative
4a28:    mov	#-0x1, r15
4a2a:    pop	r6
4a2c:    pop	r7
4a2e:    pop	r8
4a30:    pop	r9
4a32:    pop	r10
4a34:    pop	r11
4a36:    ret
4b66 <run>
4b66:    push	r11
4b68:    push	r10
4b6a:    push	r9
4b6c:    push	r8
4b6e:    push	r7
4b70:    add	#0xfa00, sp
4b74:    mov	#0x5, r14
4b78:    mov	#0x3, r15
4b7c:    call	$4778 <create_hash_table>;
4b80:    mov	r15, r8                  ; r8=pHashTableRoot
4b82:    mov	#0x4a38, r15             ; output stuff
4b86:    call	$4d50 <puts>             
4b8a:    mov	#0x4a58, r15             
4b8e:    call	$4d50 <puts>
4b92:    mov	#0x4a95, r15
4b96:    call	$4d50 <puts>             ; till here
4b9a:    clr	r14
4b9c:    mov	#0x5ff, r7               ; zero 0x5ff bytes from sp up
4ba0:    jmp	$4bac 
4ba2:    mov	sp, r15
4ba4:    add	r14, r15
4ba6:    mov.b	#0x0, 0x0(r15)
4baa:    inc	r14
4bac:    cmp	r14, r7
4bae:    jge	$4ba2 
4bb0:    mov	#0x550, r14              ; getsn number of chars
4bb4:    mov	sp, r15                  ; getsn pointer
4bb6:    call	$4d40 <getsn>            ; read up to 0x550 bytes into sp
4bba:    mov	sp, r11                  ; r11=pInputData
4bbc:    jmp	$4ce2 
4bbe:    cmp.b	#0x61, r15             ; cmp first byte to 'a'
4bc2:    jnz	$4c38                    ; jump if not 'a'
4bc4:      mov	r11, r14                 ; load input pointer into r14 and skip 7 chars
4bc6:      add	#0x7, r14                ; r14=pName
4bca:      mov	r14, r11                 ; r11=pName
4bcc:      jmp	$4bdc                    ; read characters till space
4bce:      cmp.b	#0x20, r15             ; is character a space?
4bd2:      jnz	$4bda                    ; jump if not a space
4bd4:      mov.b	#0x0, 0x0(r11)         ; move a zero on space
4bd8:      jmp	$4be2 
4bda:      inc	r11
4bdc:      mov.b	@r11, r15              ; load current input char
4bde:      tst.b	r15                    ; test current char is zero
4be0:      jnz	$4bce                    ; jump if not zero
4be2:      inc	r11                      ; increment r11 to next input char after space
4be4:      clr	r10
4be6:      jmp	$4bfe 
4be8:      mov	r10, r13                 ; r13=hashedPin
4bea:      add	r13, r13
4bec:      add	r13, r13
4bee:      add	r10, r13
4bf0:      add	r13, r13
4bf2:      mov.b	@r11, r10
4bf4:      sxt	r10
4bf6:      add	#0xffd0, r10
4bfa:      add	r13, r10                 ; final result of hasing will be in r13
4bfc:      inc	r11
4bfe:      mov.b	@r11, r15              ; load next char after space 'access foo V'
4c00:      tst.b	r15                    ;
4c02:      jz	$4c0a                      ; jump if char is zero
4c04:      cmp.b	#0x3b, r15             ; cmp byte to ';'
4c08:      jnz	$4be8                    ; jump if not a ';'
4c0a:      mov	r8, r15                  ; r15=pHashTableRoot
4c0c:      call	$49cc <get_from_table>   ; (r13=hashedPin, r14=pName, r15=pHashTableRoot)
4c10:      cmp	#-0x1, r15
4c12:      jnz	$4c1a 
4c14:      mov	#0x4a96, r15             ; load 'no such box' into r15
4c18:      jmp	$4c9c                    ; 
4c1a:      xor	r15, r10
4c1c:      and	#0x7fff, r10
4c20:      jnz	$4c32 
4c22:      cmp	r10, r15
4c24:      jge	$4c2c 
4c26:      mov	#0x4aa3, r15             ; load 'access granted'
4c2a:      jmp	$4c9c 
4c2c:      mov	#0x4ab3, r15             ; load 'access granted; but account not activated'
4c30:      jmp	$4c9c 
4c32:      mov	#0x4ade, r15             ; load 'access denied'
4c36:      jmp	$4c9c 
4c38:    cmp.b	#0x6e, r15             ; cmp first byte to 'n'
4c3c:      jnz	$4cbe                  ; jump if not 'n'
4c3e:      mov	r11, r9                ; r9=pInputData
4c40:      add	#0x4, r9               ; r9+=4=pName
4c42:      mov	r9, r11                ; r11=pName
4c44:      jmp	$4c54 
4c46:      cmp.b	#0x20, r15           ; is *pName <space>
4c4a:      jnz	$4c52                  ; 
4c4c:      mov.b	#0x0, 0x0(r11)       ; *pName == ' ' -> *pName = 0
4c50:      jmp	$4c5a 
4c52:      inc	r11                    ; *pname != ' ' -> pName++
4c54:      mov.b	@r11, r15            ; r15=*pName
4c56:      tst.b	r15
4c58:      jnz	$4c46                  ; jump if *pName is not zero
4c5a:      inc	r11                    ; pName++; r11=pPin
4c5c:      clr	r10
4c5e:      jmp	$4c76 
4c60:      mov	r10, r12               ; r12=hashedPin
4c62:      add	r12, r12
4c64:      add	r12, r12
4c66:      add	r10, r12
4c68:      add	r12, r12
4c6a:      mov.b	@r11, r10
4c6c:      sxt	r10
4c6e:      add	#0xffd0, r10
4c72:      add	r12, r10
4c74:      inc	r11
4c76:      mov.b	@r11, r15             
4c78:      tst.b	r15                  ;
4c7a:      jz	$4c82                    ; *pPin == 0
4c7c:      cmp.b	#0x3b, r15           ;
4c80:      jnz	$4c60                  ; *pPin != ';'
4c82:      tst	r10
4c84:      jge	$4c8c 
4c86:      mov	#0x4aec, r15           ; load 'Can not have a pin with high bit set'
4c8a:      jmp	$4c9c                  ; done
4c8c:      mov	r9, r14                ; p14=pInputData
4c8e:      mov	r8, r15                ; p15=pHashTableRoot
4c90:      call	$49cc <get_from_table>
4c94:      cmp	#-0x1, r15
4c96:      jz	$4ca2 
4c98:      mov	#0x4b12, r15           ; load 'User already has an account'
4c9c:      call	$4d50 <puts>
4ca0:      jmp	$4cda
4ca2:      push	r10
4ca4:      push	r9
4ca6:      push	#0x4b2f                ; push 'Adding user account %s with pin %x'
4caa:      call	$4448 <printf>
4cae:      add	#0x6, sp
4cb2:      mov	r10, r13
4cb4:      mov	r9, r14
4cb6:      mov	r8, r15
4cb8:      call	$4832 <add_to_table>
4cbc:      jmp	$4cda 
4cbe:    mov	#0x4b54, r15             ; load 'Invalid command'
4cc2:    call	$4d50 <puts>             ; output invalid command and return
4cc6:    mov	#0x1, r15
4cc8:    add	#0x600, sp
4ccc:    pop	r7
4cce:    pop	r8
4cd0:    pop	r9
4cd2:    pop	r10
4cd4:    pop	r11
4cd6:    ret
4cd8:    inc	r11                   
4cda:    cmp.b	#0x3b, 0x0(r11)        ; When 'User already has an account' or 'Adding user account'
4ce0:    jz	$4cd8                      ; probably we want to use that somehow?
4ce2:    mov.b	@r11, r15
4ce4:    tst.b	r15
4ce6:    jnz	$4bbe 
4ce8:    clr	r14
4cea:    jmp	$4bac 
4cec <INT>
4cec:  1e41 0200      mov	0x2(sp), r14
4cf0:  0212           push	sr
4cf2:  0f4e           mov	r14, r15
4cf4:  8f10           swpb	r15
4cf6:  024f           mov	r15, sr
4cf8:  32d0 0080      bis	#0x8000, sr
4cfc:  b012 1000      call	$0010
4d00:  3241           pop	sr
4d02:  3041           ret
4d04 <putchar>
4d04:  2183           decd	sp
4d06:  0f12           push	r15
4d08:  0312           push	#0x0
4d0a:  814f 0400      mov	r15, 0x4(sp)
4d0e:  b012 ec4c      call	$4cec <INT>
4d12:  1f41 0400      mov	0x4(sp), r15
4d16:  3150 0600      add	#0x6, sp
4d1a:  3041           ret
4d1c <getchar>
4d1c:  0412           push	r4
4d1e:  0441           mov	sp, r4
4d20:  2453           incd	r4
4d22:  2183           decd	sp
4d24:  3f40 fcff      mov	#0xfffc, r15
4d28:  0f54           add	r4, r15
4d2a:  0f12           push	r15
4d2c:  1312           push	#0x1
4d2e:  b012 ec4c      call	$4cec <INT>
4d32:  5f44 fcff      mov.b	-0x4(r4), r15
4d36:  8f11           sxt	r15
4d38:  3150 0600      add	#0x6, sp
4d3c:  3441           pop	r4
4d3e:  3041           ret
4d40 <getsn>
4d40:  0e12           push	r14
4d42:  0f12           push	r15
4d44:  2312           push	#0x2
4d46:  b012 ec4c      call	$4cec <INT>
4d4a:  3150 0600      add	#0x6, sp
4d4e:  3041           ret
4d50 <puts>
4d50:  0b12           push	r11
4d52:  0b4f           mov	r15, r11
4d54:  073c           jmp	$4d64 
4d56:  1b53           inc	r11
4d58:  8f11           sxt	r15
4d5a:  0f12           push	r15
4d5c:  0312           push	#0x0
4d5e:  b012 ec4c      call	$4cec <INT>
4d62:  2152           add	#0x4, sp
4d64:  6f4b           mov.b	@r11, r15
4d66:  4f93           tst.b	r15
4d68:  f623           jnz	$4d56 
4d6a:  3012 0a00      push	#0xa
4d6e:  0312           push	#0x0
4d70:  b012 ec4c      call	$4cec <INT>
4d74:  2152           add	#0x4, sp
4d76:  0f43           clr	r15
4d78:  3b41           pop	r11
4d7a:  3041           ret
4d7c <strcmp>
4d7c:  033c           jmp	$4d84 
4d7e:  4d93           tst.b	r13
4d80:  0b24           jz	$4d98 
4d82:  1f53           inc	r15
4d84:  6d4f           mov.b	@r15, r13
4d86:  6c4e           mov.b	@r14, r12
4d88:  1e53           inc	r14
4d8a:  4d9c           cmp.b	r12, r13
4d8c:  f827           jz	$4d7e 
4d8e:  4f4d           mov.b	r13, r15
4d90:  5e4e ffff      mov.b	-0x1(r14), r14
4d94:  0f8e           sub	r14, r15
4d96:  3041           ret
4d98:  0f43           clr	r15
4d9a:  3041           ret
4d9c <_unexpected_>
4d9c:  0013           reti	pc
