anchor.diff:          (setf (serial-proto:person.spouse person) spouse)
           (setf (serial-proto:person.odd-p person) (oddp count))
           (push person (serial-proto:population.people population))))
  -    (print "Proto3 Performance Test Serialization")
  -    (benchmark:with-timing (1000)
  -      (serialize-to-bytes population (type-of population)))
  -    (let* ((buffer (serialize-to-bytes population (type-of population)))
  -           (result (deserialize-from-bytes (type-of population) buffer)))
  -      (assert-true (proto-equal population result :exact t))
  -
  -      (print "Proto3 Performance Test Deserialization")
  +    (print "Proto2 Performance Test Serialization")
  +    (benchmark:with-timing (1000)
  +      (serialize-to-bytes population (type-of population)))
  +    (let* ((buffer (serialize-to-bytes population (type-of population)))
  +           (result (deserialize-from-bytes (type-of population) buffer)))
  +      (assert-true (proto-equal population result :exact t))
  +
  +      (print "Proto2 Performance Test Deserialization")
         (benchmark:with-timing (1000)
           (deserialize-from-bytes (type-of population) buffer)))
       (proto2-create-serialization-functions)
  -    (print "Proto3 Performance Test Serialization Optimized")
  -    (benchmark:with-timing (1000)
  -      (serialize-to-bytes population (type-of population)))
  -    (let* ((buffer (serialize-to-bytes population (type-of population)))
  -           (result (deserialize-from-bytes (type-of population) buffer)))
  -      (assert-true (proto-equal population result :exact t))
  -
  -      (print "Proto3 Performance Test Deserialization Optimized")
  +    (print "Proto2 Performance Test Serialization Optimized")
  +    (benchmark:with-timing (1000)
  +      (serialize-to-bytes population (type-of population)))
  +    (let* ((buffer (serialize-to-bytes population (type-of population)))
  +           (result (deserialize-from-bytes (type-of population) buffer)))
  +      (assert-true (proto-equal population result :exact t))
  +
  +      (print "Proto2 Performance Test Deserialization Optimized")
         (benchmark:with-timing (1000)
           (deserialize-from-bytes (type-of population) buffer)))
       (clear-proto2-serialization-functions)))
  
positive.code:                          proto3-proto:address
                           proto3-proto:person)
          do
             (clear-serialization-functions message)))
  
  (defun proto3-create-serialization-functions ()
    (pi::make-serializer proto3-proto:population)
  
negative.code: 
  (deftest basic-function-times (timing-suite)
    (print "Optional Field Test")
    (let ((iterations 10000))
      (benchmark:with-timing (iterations)
        (let ((optional-message (serial-proto:make-optional-message)))
          (serial-proto:optional-message.has-optional-no-default optional-message)
          (setf (serial-proto:optional-message.optional-no-default optional-message) 2)
          (serial-proto:optional-message.has-optional-no-default optional-message)
          (serial-proto:optional-message.clear-optional-no-default optional-message)))
      (print "Required Field Test")
      (benchmark:with-timing (iterations)
        (let ((required-message (serial-proto:make-required-message)))
          (serial-proto:required-message.has-required-no-default required-message)
          (setf (serial-proto:required-message.required-no-default required-message) 2)
          (serial-proto:required-message.has-required-no-default required-message)
          (serial-proto:required-message.clear-required-no-default required-message)))
      (print "Oneof Field Test")
      (benchmark:with-timing (iterations)
        (let ((oneof-proto (oneof-proto:make-oneof-proto :intval 2)))
          (oneof-proto:oneof-proto.has-intval oneof-proto)
          (setf (oneof-proto:oneof-proto.intval oneof-proto) 2)
          (oneof-proto:oneof-proto.has-intval oneof-proto)
          (oneof-proto:oneof-proto.clear-intval oneof-proto)))
      (print "Map Field Test")
      (benchmark:with-timing (iterations)
        (let ((map-proto (map-proto:make-map-all)))
          (map-proto:map-all.has-intmap map-proto)
          (setf (map-proto:map-all.intmap-gethash 1 map-proto) 1)
          (map-proto:map-all.has-intmap map-proto)
          (map-proto:map-all.clear-intmap map-proto)))
      (print "Singular Field Test")
      (benchmark:with-timing (iterations)
        (let ((singular-proto (proto3-proto:make-all-singular)))
          (proto3-proto::all-singular.has-int32-value singular-proto)
          (setf (proto3-proto::all-singular.int32-value singular-proto) 1)
          (proto3-proto::all-singular.has-int32-value singular-proto)
          (proto3-proto:all-singular.clear-int32-value singular-proto)))
      (assert t)))
  
  (defvar *presidents*
    '("George Washington" "John Adams" "Thomas Jefferson"
  