diff --git a/typed-racket-lib/typed-racket/rep/rep-utils.rkt b/typed-racket-lib/typed-racket/rep/rep-utils.rkt
index cbe650ac..c6d5b6bd 100644
--- a/typed-racket-lib/typed-racket/rep/rep-utils.rkt
+++ b/typed-racket-lib/typed-racket/rep/rep-utils.rkt
@@ -32,9 +32,9 @@
 (define-struct Rep (seq free-vars free-idxs stx) #:transparent
                #:methods gen:equal+hash
                [(define (equal-proc x y recur)
-                  (eq? (unsafe-Rep-seq x) (unsafe-Rep-seq y)))
-                (define (hash-proc x recur) (unsafe-Rep-seq x))
-                (define (hash2-proc x recur) (unsafe-Rep-seq x))])
+                  (eq? (Rep-seq x) (Rep-seq y)))
+                (define (hash-proc x recur) (Rep-seq x))
+                (define (hash2-proc x recur) (Rep-seq x))])
 
 ;; evil tricks for hygienic yet unhygienic-looking reference
 ;; in say def-type for type-ref-id
@@ -360,11 +360,6 @@
                 [Object def-object #:Object object-case print-object object-name-ht object-rec-id]
                 [PathElem def-pathelem #:PathElem pathelem-case print-pathelem pathelem-name-ht pathelem-rec-id])
 
-;; NOTE: change these if the definitions above change, or everything will segfault
-(define-syntax-rule (unsafe-Rep-seq v) (Rep-seq v))
-(define-syntax-rule (unsafe-Type-key v) (Type-key v))
-(provide unsafe-Rep-seq unsafe-Type-key)
-
 (define (Rep-values rep)
   (match rep
     [(? (lambda (e) (or (Filter? e)
diff --git a/typed-racket-lib/typed-racket/types/subtype.rkt b/typed-racket-lib/typed-racket/types/subtype.rkt
index bb7c8362..1c190a28 100644
--- a/typed-racket-lib/typed-racket/types/subtype.rkt
+++ b/typed-racket-lib/typed-racket/types/subtype.rkt
@@ -237,8 +237,8 @@
 ;; is s a subtype of t, taking into account previously seen pairs A
 (define/cond-contract (subtype* A s t)
   (c:-> (c:listof (c:cons/c fixnum? fixnum?)) Type? Type? c:any/c)
-  (define ss (unsafe-Rep-seq s))
-  (define st (unsafe-Rep-seq t))
+  (define ss (Rep-seq s))
+  (define st (Rep-seq t))
   (early-return
    #:return-when (or (eq? ss st) (seen? ss st A)) A
    (define cr (let ([inner (hash-ref subtype-cache st #f)])
@@ -246,8 +246,8 @@
                     (hash-ref inner ss 'missing)
                     'missing)))
    #:return-when (boolean? cr) (and cr A)
-   (define ks (unsafe-Type-key s))
-   (define kt (unsafe-Type-key t))
+   (define ks (Type-key s))
+   (define kt (Type-key t))
    #:return-when (and (symbol? ks) (symbol? kt) (not (eq? ks kt))) #f
    #:return-when (and (symbol? ks) (pair? kt) (not (memq ks kt))) #f
    #:return-when