diff --git a/apps/lib/parse.asm b/apps/lib/parse.asm
index 6ab6e16..bf59f4e 100644
--- a/apps/lib/parse.asm
+++ b/apps/lib/parse.asm
@@ -1,5 +1,5 @@
 ; *** Requirements ***
-; unsetZ
+; None
 ;
 ; *** Code ***
 
@@ -7,58 +7,72 @@
 ; result in A.
 ;
 ; On success, the carry flag is reset. On error, it is set.
-parseDecimalDigit:
-	; First, let's see if we have an easy 0-9 case
-	cp	'0'
-	ret	c	; if < '0', we have a problem
-	sub	'0'		; our value now is valid if it's < 10
-	cp	10		; on success, C is set, which is the opposite
-				; of what we want
-	ccf			; invert C flag
-	ret
+; Also, zero flag set if '0'
+; parseDecimalDigit has been replaced with the following code inline:
+;	add a, 0xc6	; Maps '0'-'9' onto 0xf6-0xff
+;	sub 0xf6	; Anything but 0xf6-0xff carries
+			; Maps 0xf6-0xff onto 0-9 
 
 ; Parse string at (HL) as a decimal value and return value in IX under the
 ; same conditions as parseLiteral.
 ; Sets Z on success, unset on error.
+
+; 55 bytes, 32 cycles in first loop
+; 90 cycles overhead + up to 69 cycles if length >= 5
+; 140 cycles in loop
 parseDecimal:
-	push	hl
-	push	de
+	push 	hl
 
-	ld	ix, 0
-.loop:
+.skip:	; Skips leading zeroes
 	ld	a, (hl)
-	or	a
-	jr	z, .end	; success!
-	call	parseDecimalDigit
-	jr	c, .error
-
-	; Now, let's add A to IX. First, multiply by 10.
-	push	ix \ pop de
-	add	ix, ix	; x2
-	jr	c, .error
-	add	ix, ix	; x4
-	jr	c, .error
-	add	ix, ix	; x8
-	jr	c, .error
-	add	ix, de	; x9
-	jr	c, .error
-	add	ix, de	; x10
-	jr	c, .error
-	ld	d, 0
-	ld	e, a
-	add	ix, de
-	jr	c, .error
-
 	inc	hl
-	jr	.loop
+	cp	'0'
+	jr	z, .skip
 
-	cp	a	; ensure Z
-	jr	.end
+	exx		; preserve bc, hl, de
+	ld	hl, 0
+	ld	b, 5	; Carries can only occur for decimals >=5 in length
+	jr	.start
+
+.loop:
+	ld	c, a		; c holds current digit
+	exx	;swap hl back in to get address
+	ld	a, (hl)	; a checks if following digit is null at end of loop
+	inc	hl
+	exx
+	add	hl, hl	; x2
+	ld	d, h
+	ld	e, l		; de is x2
+	add	hl, hl	; x4
+	add	hl, hl	; x8
+	add	hl, de	; x10
+	ld	d, 0
+	ld	e, c
+	add	hl, de
+	jr	c, .error	; if hl was 0x1999, it may carry here
+	; This check could be taken outside the loop, but at the cost of 6 bytes
+
+.start:
+	add	a, 0xc6	; converts '0'-'9' to 0-9
+	sub	0xf6	; carries if out of range
+	jr	c, .error
+
+	djnz	.loop
+
+
+	inc 	b	; so loop only executes once more
+	; only numbers >0x1999 can carry when multiplied by 10.
+	ld	de, 0xE666	
+	ex	de, hl
+	add	hl, de
+	ex	de, hl
+	jr	nc, .loop	; if it doesn't carry, it's small enough
 .error:
-	call	unsetZ
+	sub 	0xd0	; if a is null, set Z
+			; a is checked for null before any errors
 .end:
-	pop	de
-	pop	hl
+	push	hl
+	pop	ix
+	exx	; restore original de and bc
+	pop	hl	
 	ret
-
-