diff --git a/04-typed-racket/main.rkt b/04-typed-racket/main.rkt
index 227484d..e88de19 100644
--- a/04-typed-racket/main.rkt
+++ b/04-typed-racket/main.rkt
@@ -57,32 +57,49 @@
         (Node 6 end (Node 11 end end))
         (Node 12 end end)))
 
-(: good-bt? : (BT -> Boolean))
+; <2: U{Num, Sym}, Num, U{Num, Sym} → Bool
+(: <2 : ((U Number Symbol) Number (U Number Symbol) -> Boolean))
+; Convenient form of greater than. Slightly hack.
+(define (<2 a b c)
+  (cond [(and (symbol? a) (symbol? c)) #t]
+        [(symbol? a) (< b c)]
+        [(symbol? c) (< a b)]
+        [else (< a b c)]))
+
+; recurse: t: Tree, lower: U{Num, Sym}, upper: U{Num, Sym} → Bool
+(: good-bt?r : (BT (U Number Symbol) (U Number Symbol) -> Boolean))
+; Recursively checks left & right with lower & upper bounds.
+(define (good-bt?r t lower upper)
+  (cases t
+    [(Node n t1 t2) (and (<2 lower n upper)
+                         (good-bt?r t1 lower n)
+                         (good-bt?r t2 n upper))]
+    [(End what) #t]))
+
 ; good-bt?: t BT → Bool
+(: good-bt? : (BT -> Boolean))
 ; Determine whether bt is good.
 (define (good-bt? t)
-  (cases t
-    [end (symbol]))
-#|  (local [; <2: U{Num, Sym}, Num, U{Num, Sym} → Bool
-          (: (U Number Symbol))
-          ; Convenient form of greater than. Slightly hack.
-          (define (<2 a b c)
-            (cond [(and (symbol? a) (symbol? c)) #t]
-                  [(symbol? a) (< (- b 1) b c)]
-                  [(symbol? c) (< a b (+ b 1))]
-                  [else (< a b c)]))
+  (good-bt?r t 'quite-little 'very-big))
 
-          ; recurse: t: Tree, lower: Num, upper: Num → Bool
-          ; Recursively checks left & right with lower & upper bounds.
-          (define (recurse t lower upper)
-            (cond [(symbol? t) (symbol=? t 'end)]
-                  [else (and (<2 lower (tree-n t) upper)
-                             (recurse (tree-left t) lower (tree-n t))
-                             (recurse (tree-right t) (tree-n t) upper))]))]
-         (recurse t 'quite-little 'very-big)))|#
+(test (good-bt? sprout) => #t)
+(test (good-bt? sapling) => #t)
+(test (good-bt? deeply-broke-tree) => #f)
 
-(check-expect (bst? sprout) #t)
-(check-expect (bst? sapling) #t)
-(check-expect (bst? good-tree) #t)
-(check-expect (bst? broke-tree) #f)
-(check-expect (bst? deeply-broke-tree) #f)
\ No newline at end of file
+; goodies/help: l: [A], i: Index, a: [Index] → [Index]
+(: goodies/help : (All(A) (A -> Boolean) (Listof A) Number (Listof Number) -> (Listof Number)))
+(define (goodies/help good? l i a)
+  (match l
+    ['() (reverse a)]
+    [(cons f r) (if (good? f)
+                    (goodies/help good? r (add1 i) (cons i a))
+                    (goodies/help good? r (add1 i) a))]))
+
+; goodies: good?: (A → Boolean), l: [A] → [Index]
+(: goodies : (All(A) (A -> Boolean) (Listof A) -> (Listof Number)))
+; Returns a list of indices considered "good."
+(define (goodies good? l)
+  (goodies/help good? l 0 '()))
+
+(test (goodies even? '(1 2 3 4 5)) => '(1 3))
+(test (goodies even? '()) => '())
\ No newline at end of file