Church numerals in early lisp implementations?

McCarthy wrote this in ``History of Lisp''.

Numbers were originally implemented in LISP I as lists of atoms, and
this proved too slow for all but the simplest computations.

Was that Church numerals?  Does anyone have examples of code from back
then?  I'm picturing things such as

  (defconstant zero nil)
  (defconstant one (cons nil zero))

  (defun zero? (x) (eq zero x))
  (defun add1 (x) (cons nil x))
  (defun sub1 (x) (cdr x))

  (defun add (x y)
    (cond ((zero? x) y)
          (t (add (sub1 x) (add1 y)))))

  CL-USER> (add one one)
  (NIL NIL)

The paragraph continued:

A reasonably efficient implementation of numbers as atoms in
S-expressions was made in LISP 1.5, but in all the early LISPs,
numerical computations were still 10 to 100 times slower than in
FORTRAN. Efficient numerical computation requires some form of typing
in the source language and a distinction between numbers treated by
themselves and as elements of S-expressions. Some recent versions of
LISP allow distinguishing types, but at the time, this seemed
incompatible with other features.